<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Don Kinghorn on Medium]]></title>
        <description><![CDATA[Stories by Don Kinghorn on Medium]]></description>
        <link>https://medium.com/@dkinghorn?source=rss-67d0baf520ea------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*mk9NkaYG4ohBrE8ByKhxrw.jpeg</url>
            <title>Stories by Don Kinghorn on Medium</title>
            <link>https://medium.com/@dkinghorn?source=rss-67d0baf520ea------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 05:11:44 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@dkinghorn/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[TensorFlow 2 (GPU) with Anaconda Python (no separate CUDA install needed)]]></title>
            <link>https://medium.com/@dkinghorn/tensorflow-2-gpu-with-anaconda-python-no-separate-cuda-install-needed-d10cddb444b1?source=rss-67d0baf520ea------2</link>
            <guid isPermaLink="false">https://medium.com/p/d10cddb444b1</guid>
            <category><![CDATA[python]]></category>
            <category><![CDATA[nvidia]]></category>
            <category><![CDATA[anaconda]]></category>
            <category><![CDATA[cuda]]></category>
            <category><![CDATA[tensorflow2]]></category>
            <dc:creator><![CDATA[Don Kinghorn]]></dc:creator>
            <pubDate>Wed, 16 Oct 2019 22:04:32 GMT</pubDate>
            <atom:updated>2019-10-16T22:04:32.962Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/740/1*hMumWX8M9HflOcZLo2y2gQ.png" /></figure><h3><strong>Introduction</strong></h3><p>TensorFlow 2.0 is released!</p><p>What if you want to use it but don’t want to mess with doing an NVIDIA CUDA install on your system. The official TensorFlow install documentations has you do that, but it’s really not necessary. At least not a direct CUDA install …</p><blockquote>This post will give you 3 simple options to setup TensorFlow2.0 using Anaconda Python on Windows 10 or Linux. (It’s essentially the same in both OS’s.)</blockquote><h3><strong>The basic idea</strong></h3><p>I’m using <a href="https://www.anaconda.com/distribution/">Anaconda Python</a> which has largely become “the” standard Python distribution for data-science, ML/AI and scientific computing. It’s not perfect but it’s nicely done. Your opinion may differ and I understand reasons for that, but I still find it easy to recommend Anaconda Python.</p><p>Installing TensorFlow with GPU support using Anaconda Python can be as simple as creating an “env” for it and then running a simple install command.</p><p><strong>However, right now the latest TensorFlow version available on Anaconda Cloud is version 1.14. … but we’ll check that …</strong></p><p>The official TensorFlow install documentation for GPU acceleration has you do a CUDA install on your system. <strong>… but you don’t have to install CUDA outside of a conda env!</strong></p><p><strong>TensorFlow 2.0 on pypi is being built with links to CUDA 10.0 and cuDNN 7.6. Those are the same dependencies as TensorFlow-GPU 1.13.1 “anaconda” packaged version on Anaconda cloud. We can use that information!</strong></p><h3>3 Ways to get TensorFlow 2 installed with Anaconda Python</h3><ul><li>If it’s been officially packaged then it’s trivial (not available when I wrote this)</li><li>Clone an Anaconda version of TensorFlow (1.13.1) with the right dependencies and then overwrite with TensorFlow 2.0</li><li>Manually add the needed dependencies to an env and then pip install TensorFlow 2.0</li></ul><h3>1) Stop here if the official Anaconda tensorflow-gpu package has been updated to version 2.</h3><p>Check the packages on <a href="https://anaconda.org/search?q=tensorflow">Anaconda Cloud for tensorflow-gpu</a> to see if it’s been updated (or started in a separate named package) for TensorFlow 2.0.</p><p>If it is updated, then the 3 commands below will get you going.</p><pre>conda create --name tf2-gpu</pre><pre>conda activate tf2-gpu</pre><pre>conda install tensorflow2-gpu<br># Note: I don&#39;t know what they will call the package name<br># maybe just tensorflow-gpu ??</pre><h3>2) Clone version 1.13.1 and pip install version 2.0 on top of that</h3><p>We can use TensorFlow 1.13.1 from Anaconda Cloud as a base for the install to get the needed dependencies of TensorFlow 2.0 and then “pip” install TensorFlow 2.0 on top of that.</p><h4>Start with a version specific env for 1.13.1</h4><pre>conda create --name tf-gpu-1.13.1</pre><pre>conda activate tf-gpu-1.13.1</pre><pre>conda install tensorflow-gpu=1.13.1</pre><p>Note: I used version 1.13.1 because when I have tried with 1.14 I got CUDA 10.1 along with it, which will not work with TensorFlow 2.0 from pypi.</p><h4>Clone the existing tf-gpu-1.13.1 env and call it tf2-gpu,</h4><pre>conda create --name tf2-gpu --clone tf-gpu-1.13.1</pre><p>Next activate the new env and use “pip” in that conda environment to install the new TensorFlow-GPU 2.0</p><h4>Activate the “env”</h4><pre>conda activate tf2-gpu</pre><h4>Pip install TensorFlow 2.0</h4><pre>pip install tensorflow-gpu==2.0</pre><p>You now have a base with most of the dependencies including CUDA from the original Anaconda tensorflow-gpu install and pip will pull down the new Google TensorFlow 2.0 package from pypi along with any other needed dependencies. The old TensorFlow will still be in the env but when you import tensorflow you will get the newest version in the env, which will be TensorFlow 2.0.</p><h3>3) Setup a conda env with the critical dependencies and pip install TensorFlow 2.0</h3><p>This may be the best way to do the install.</p><h4>Create and activate the base env</h4><pre>conda create --name tf2-gpu</pre><pre>conda activate tf2-gpu</pre><h4>Now install the dependencies from the anaconda channel</h4><pre>conda install cudatoolkit=10.0 cudnn=7.6 cupti=10.0 blas numpy pip scipy</pre><p>That will give you the core dependency base that would be installed from a tensorflow-gpu=1.13.1 install. The remaining dependencies will be mostly TensorFlow specific, and we will get those resolved from pip in the next step.</p><p><strong>Note:</strong> If you want to maximize the number of packages that come from the anaconda channel you could also install hdf5 h5py astor gast mock markdown absl-py grpcio c-ares Dependencies and versions will be resolved by conda from both pypi and anaconda channel in the next step.</p><h4>pip install TensorFlow 2.0 from pypi</h4><pre>pip install tensorflow-gpu==2.0</pre><p><strong>That’s it! You now have TensorFlow 2.0 installed with CUDA support for your NVIDIA GPU in Anaconda Python.</strong></p><h3>Extra stuff!</h3><p>Following are a few tips to help get you on your way to TensorFlow 2.0 bliss if you need them.</p><h4>Create a Jupyter kernel for your new env,</h4><p>Make sure ipykernel and Jupyter are installed,</p><pre>conda activate tf2-gpu<br>conda install ipykernel jupyter</pre><p>make the kernel,</p><pre>python -m ipykernel install --user --name tf2-gpu --display-name “TensorFlow-GPU-2.0”</pre><p>You should now be able to fire up a jupyter notebook select your new tensorFlow 2.0 env kernel and go to work!</p><h4><strong>Install Anaconda Python</strong></h4><p>If you have read this far and do not have Anaconda Python installed but would like to try it then I’m going to refer you to some other posts for doing this.</p><p>For Windows 10 look at <a href="https://www.pugetsystems.com/labs/hpc/How-to-Install-TensorFlow-with-GPU-Support-on-Windows-10-Without-Installing-CUDA-UPDATED-1419/"><strong>How to Install TensorFlow with GPU Support on Windows 10 (Without Installing CUDA) UPDATED!</strong></a>. That post is very detailed and should get you up and running with Anaconda Python and the current version of TensorFlow with CUDA GPU support. I recommend that Linux users take a look at this post too since it is up-to-date and has good general information in it.</p><p>An older post that is still relevant for Linux users is, <a href="https://www.pugetsystems.com/labs/hpc/Install-TensorFlow-with-GPU-Support-the-Easy-Way-on-Ubuntu-18-04-without-installing-CUDA-1170/"><strong>Install TensorFlow with GPU Support the Easy Way on Ubuntu 18.04 (without installing CUDA)</strong></a>. This post is a over a year old now but still mostly OK. I have some updated notes in it. Really, it’s pretty straight forward getting Anaconda Python installed on Linux and the information in the Windows 10 post is pertinent as well, read that even if you are using Linux.</p><p>Those guides above will walk you thought the Anaconda install if needed. They cover the setup process in detail and have a testing example coded in Keras so you can see that everything is work right.</p><p>If you like this post then you may enjoy some of the posts I have in the <a href="https://www.pugetsystems.com/all_hpc.php"><strong>HPC blog at Puget System</strong></a><strong>s</strong>.</p><p><strong>Happy computing! — dbk @dbkinghorn</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/200/1*PBA2dAa49Jno_YhCnjHfvw.jpeg" /><figcaption>Dr Kinghorn is the Scientific Computing adviser at Puget Systems <a href="https://www.pugetsystems.com/">https://www.pugetsystems.com/</a></figcaption></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d10cddb444b1" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Workstation Setup for Docker with the New NVIDIA Container Toolkit (nvidia-docker2 is deprecated)]]></title>
            <link>https://medium.com/@dkinghorn/workstation-setup-for-docker-with-the-new-nvidia-container-toolkit-nvidia-docker2-is-deprecated-2243231d48c6?source=rss-67d0baf520ea------2</link>
            <guid isPermaLink="false">https://medium.com/p/2243231d48c6</guid>
            <category><![CDATA[scientific-computing]]></category>
            <category><![CDATA[docker]]></category>
            <category><![CDATA[nvidia]]></category>
            <category><![CDATA[gpu-computing]]></category>
            <category><![CDATA[machine-learning]]></category>
            <dc:creator><![CDATA[Don Kinghorn]]></dc:creator>
            <pubDate>Mon, 30 Sep 2019 20:12:55 GMT</pubDate>
            <atom:updated>2019-09-30T20:12:55.493Z</atom:updated>
            <content:encoded><![CDATA[<h3>Introduction</h3><p>It’s time for a “Docker with NVIDIA GPU support” update. This post will guide you through a useful Workstation setup (including User-name-spaces and performance tuning) with the new versions of Docker and the NVIDIA GPU container toolkit.</p><p>If you read many of my blog posts you will know that I user Docker with NVIDIA GPU support a lot. I have been writing about Docker for a few years now and a <a href="https://www.pugetsystems.com/all_hpc.php?query=Docker">search for docker on the Puget Systems HPC blog</a> brings up over 100 posts! The most recent was a “careful” post, <a href="https://www.pugetsystems.com/labs/hpc/How-To-Install-Docker-and-NVIDIA-Docker-on-Ubuntu-19-04-1460/">How To Install Docker and NVIDIA-Docker on Ubuntu 19.04</a> that went through a setup with attention to version “gotchas”. That was using the Docker 18.09 release with nvidia-docker2 2.0.3. <strong>Things have changed!</strong></p><p><strong>As of Docker release 19.03 NVIDIA GPUs are natively supported as devices in the Docker runtime. And, nvidia-docker2 is deprecated!</strong></p><p>I’ll go through the docker + NVIDIA GPU setup in a series of steps. The end result will be an up-to-date configuration suitable for a personal Workstation. <strong>This will include performance tuning for GPU acceleration and a “single user friendly” file ownership config utilizing UserNamespaces.</strong></p><p>I’m doing this guide with <strong>Ubuntu 18.04 default, and including notes for 19.04.</strong></p><h3>Why Update?</h3><ul><li>Well, the main reason is that nvidia-docker2 is deprecated and will not be maintained going forward!</li><li>The move to the built-in GPU support in Docker and the nvidia-container-toolkit should eliminate the constant update-version mismatch battle between fresh releases of docker-ce and the lag before nvidia-docker2 was updated. ( I was constantly running into that from having docker on several “production” and testing systems.)</li><li>The “practical” usage side of the change is mostly small.</li></ul><p>Instead of,</p><pre>docker run --runtime=nvidia ... or nvidia-docker run ...</pre><p>It will now look like</p><pre>docker run --gpus all ...</pre><p>There are several arguments (like “all”) to --gpus, see the <a href="https://github.com/NVIDIA/nvidia-docker/wiki">NVIDIA docker Wiki</a> and the <a href="https://docs.docker.com/engine/reference/commandline/#access-an-nvidia-gpu">documentation entry for “</a><a href="https://docs.docker.com/engine/reference/commandline/#access-an-nvidia-gpu">run --gpus”</a></p><h3>Step 1) Preparation and Clean Up</h3><p><strong>Docker:</strong></p><p>If you have an old docker install you should remove that as suggested in the docker install documentation.</p><pre>sudo apt-get remove docker docker-engine docker.io containerd runc</pre><p>If you have a docker-ce install, version 18.xx or older, that you have disabled updates on, you should re-enable the repo i.e. remove a “hold” or uncomment the repo in /etc/apt/sources.list. The updated docker will upgrade to 19.03+ with normal updates.</p><h4><strong>NVIDIA GPU Setup:</strong></h4><p>You don’t have to do much here if you already have an NVIDIA GPU and an updated driver. However, you should be sure to have a <strong>recent</strong> NVIDIA driver installed.</p><p>If you are using a new OS install then an easy way to install/update the NVIDIA display driver is to use the “graphics drivers” ppa.</p><pre>sudo add-apt-repository ppa:graphics-drivers/ppa <br>sudo apt-get update <br>sudo apt-get install build-essential dkms <br>sudo apt-get install nvidia-driver-435</pre><p>The version installed above is “435”. You can see what is the most recent driver available by visiting the <a href="https://launchpad.net/~graphics-drivers/+archive/ubuntu/ppa">ppa site</a> or by hitting [Tab] twice to expand the with apt-get i.e.</p><pre>sudo apt-get install nvidia-driver- [Tab][Tab]</pre><h4><strong>Remove nvidia-docker2</strong></h4><p>If you have been using docker-ce 18.0x along with nvidia-docker2 then you will need to remove it in order to upgrade to docker-ce 19.x.</p><pre>sudo apt-get purge nvidia-docker2</pre><p>That should be all you need to do. We will setup the nvidia-container-toolkit in a later section.</p><h3>Step 2) Install docker-ce</h3><p>The Docker community edition is simple to install and keep up-to-date on Ubuntu by adding the official repo.</p><p>We’ll be able to follow the install described in the official documentation, <a href="https://docs.docker.com/install/linux/docker-ce/ubuntu/">https://docs.docker.com/install/linux/docker-ce/ubuntu/</a></p><h4><strong>Install some required packages, (they may already be installed)</strong></h4><pre>sudo apt-get install apt-transport-https ca-certificates curl gnupg-agent software-properties-common</pre><h4><strong>Add and check the docker key,</strong></h4><pre>curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add - sudo apt-key fingerprint 0EBFCD88</pre><p>The fingerprint should match “9DC8 5822 9FC7 DD38 854A E2D8 8D81 803C 0EBF CD88”</p><h4><strong>Now add the repository</strong></h4><pre>sudo add-apt-repository &quot;deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable&quot;</pre><p><strong>Note for Ubuntu 19.04</strong> You’re in luck! docker-ce 19.03+ is fully supported on Ubuntu 19.04. Since the NVIDIA GPU support is “in” docker-ce now, there is no need to force the repo to “Bionic” to get compatibility with the NVIDIA docker setup. (However, you will have to force “ubuntu18.04” for the nvidia-container-toolkit install since NVIDIA doesn’t officially support 19.04. We’ll take care of that later.)</p><h4><strong>Install docker-ce</strong></h4><pre>sudo apt-get update <br>sudo apt-get install docker-ce docker-ce-cli containerd.io</pre><p>Note: “containerd.io” is independent of docker but included in that repository.</p><h4><strong>Check docker,</strong></h4><pre>sudo docker run --rm hello-world</pre><p>That should pull and run the hello-world container from Docker Hub. At this point only “root” can run docker. We will add user configuration in step 4).</p><h3>Step 3) Install NVIDIA Container Toolkit</h3><p><strong>Go to </strong><a href="https://github.com/NVIDIA/nvidia-docker">https://github.com/NVIDIA/nvidia-docker</a><strong> and check what is the latest Ubuntu version supported.:</strong></p><p>When I wrote this supported Ubuntu versions were 14.04, 16,04, and 18.04 (all long term support versions). If you are using Ubuntu 18.04 or one of the other LTS releases then this will be simple. If you are using Ubuntu 19.04 then you will need to make one small change.</p><h4><strong>Configure repo and install:</strong></h4><pre>distribution=$(. /etc/os-release;echo $ID$VERSION_ID) </pre><pre>curl -s -L https://nvidia.github.io/nvidia-docker/gpgkey | sudo apt-key add - </pre><pre>curl -s -L https://nvidia.github.io/nvidia-docker/$distribution/nvidia-docker.list | sudo tee /etc/apt/sources.list.d/nvidia-docker.list </pre><pre>sudo apt-get update <br>sudo apt-get install nvidia-container-toolkit <br>sudo systemctl restart docker</pre><h4><strong>Note for Ubuntu 19.04:</strong></h4><p>You will need to force the the repo to Ubuntu 18.04. The simplest thing will be to set “distribution” to ubuntu18.04 where it is used in “curl”,</p><pre>curl -s -L https://nvidia.github.io/nvidia-docker/gpgkey | sudo apt-key add - </pre><pre>curl -s -L https://nvidia.github.io/nvidia-docker/ubuntu18.04/nvidia-docker.list | sudo tee /etc/apt/sources.list.d/nvidia-docker.list </pre><pre>sudo apt-get update <br>sudo apt-get install nvidia-container-toolkit <br>sudo systemctl restart docker</pre><p>I’ve used this on several Ubuntu 19.04 installs and have not had any problems.</p><h4><strong>Test nvidia-container-toolkit:</strong></h4><p>For a quick test of your install try the following (still running as root for now),</p><pre>sudo docker run --gpus all --rm nvidia/cuda nvidia-smi</pre><p>After the container downloads you should see the nvidia-smi output from the latest NVIDIA CUDA release.</p><h3>Step 4) User Group, UserNamespace Configuration, and GPU Performance Tuning</h3><p>This section is where we turn docker into a more pleasant to use experience on a personal Workstation.</p><p><strong>The most important aspect of this section will be setting up a configuration where “you” will “own” any files you create while using a container.</strong> You will be able to mount working directories from your home directory into a container and retain full ownership of any files after the container is shutdown.</p><h4><strong>Add your user name to the docker group:</strong></h4><p>The first thing to do is add your user account to the docker group so that you can run docker without sudo.</p><pre>sudo usermod -aG docker your-user-name</pre><p><strong>Note:</strong> You will need to log out and back in for this to take effect.</p><h4><strong>Add your user and group ids as “subordinate ids”:</strong></h4><p>Now we do the configuration to give you process and file ownership from inside a container.</p><p>See, <a href="https://www.pugetsystems.com/labs/hpc/How-To-Setup-NVIDIA-Docker-and-NGC-Registry-on-your-Workstation---Part-3-Setup-User-Namespaces-1114/">How-To Setup NVIDIA Docker and NGC Registry on your Workstation — Part 3 Setup User-Namespaces</a>, for a detailed discussion of how and why you might want to do this.</p><p>Add a subordinate user and group id. I used my user-id 1000 and user-name “kinghorn”. Use your own user-name and id. You can use the id command to check your user and group ids.</p><pre>sudo usermod -v 1000-1000 kinghorn</pre><p>and a subordinate group</p><pre>sudo usermod -w 1000-1000 kinghorn</pre><h3>Gotcha #1 “subuid ordering”</h3><p>The commands above append the subuid (gid) to /etc/subuid and /etc/subgid. This “used” to be fine but now the order of entries matters. By default there will be other entries in those files including a “high ID range” default for your user. My setup looked like the following after running the above commands,</p><pre>lxd:100000:65536 <br>root:100000:65536 <br>kinghorn:165536:65536 <br>kinghorn:1000:1</pre><p>You can ignore entries for lxd and root. You can also leave entries like “kinghorn:165536:65536” in-place but you will need to move the entry like “kinghorn:1000:1” to be above higher numbered subuid’s. You will need to be root to edit the file so first do, sudo -s to get a root shell and then use you editor of choice (nano is fine) to edit the files to change the ordering, i.e. it should look more like,</p><pre>lxd:100000:65536 <br>root:100000:65536 <br>kinghorn:1000:1 <br>kinghorn:165536:65536</pre><p><strong>Edit both /etc/subuid and /etc/subgid to reflect this reordering</strong> <strong>Setup the docker configuration file for your User Namespace, and GPU compute performance optimizations:</strong></p><p>You cannot access the docker configuration directory unless you are “root” so before you edit the file /etc/docker/daemon.json do, sudo -s to give yourself a root shell and then cd /etc/docker.</p><p>If there is an existing docker “daemon.json” config file create a backup and then create a new file with the following JASON. (when I did this for testing there was no existing daemon.json file in the directory)</p><pre>{<br>    &quot;userns-remap&quot;: &quot;kinghorn&quot;,<br>    &quot;default-shm-size&quot;: &quot;1G&quot;,<br>    &quot;default-ulimits&quot;: {<br>      &quot;memlock&quot;: { &quot;name&quot;:&quot;memlock&quot;, &quot;soft&quot;:  -1, &quot;hard&quot;: -1 },<br>      &quot;stack&quot;  : { &quot;name&quot;:&quot;stack&quot;, &quot;soft&quot;: 67108864, &quot;hard&quot;: 67108864 }<br>    }<br>}</pre><p>Now do,</p><pre>chmod 600 daemon.json</pre><p>to secure the config file.</p><p><strong>Note:</strong> Be sure to to change that “kinghorn” to your own user name!</p><p>Docker will read the daemon.json file on startup.</p><p>This config sets up your “user” in the docker User Namespace. That means that even though you see a root prompt in a docker container any files you create will belong to you in your system namespace. Please reed the post I mentioned above to understand the full meaning of this.</p><p>The last part of the config JSON changes the (pitiful) default performance parameters so the you can run large GPU accelerated compute jobs.</p><pre>sudo systemctl restart docker.service</pre><p>Done!</p><h3>Examples</h3><p>If you want to use some of the (many) nice containers that NVIDIA has put together on <a href="https://ngc.nvidia.com/">NGC then go to their site</a> and see what they have put together. It’s pretty impressive!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/0*JoN3De6ckSuQsRGe" /></figure><p>If you look at the <a href="https://ngc.nvidia.com/catalog/containers/nvidia:tensorflow">TensorFlow page on NGC</a> you will see the old start-up syntax. That wont work with the new nvidia-container-toolkit! Hopefully this will get fixed soon (that may be the case by the time you read this post??)</p><p>On that page the documentation lists, <strong>(old syntax)</strong></p><pre>nvidia-docker run -it --rm -v local_dir:container_dir nvcr.io/nvidia/tensorflow:&lt;xx.xx&gt;-py&lt;x&gt;</pre><p>To use your new docker + nvidia-container-toolkit install you would need to do something like, <strong>(new syntax)</strong></p><pre>docker run --gpus all -it --rm -v local_dir:container_dir nvcr.io/nvidia/tensorflow:&lt;xx.xx&gt;-py&lt;x&gt;</pre><p>I would start up their TensorFlow container with something like,</p><pre>docker run --gpus all --rm -it -v $HOME/projects:/projects nvcr.io/nvidia/tensorflow:19.08-py3</pre><p><strong>Note:</strong> The -v $HOME/projects:/projects part of that line is binding a directory named &quot;projects&quot; in my home directory to the directory &quot;/projects&quot; in the container. Any files created there will be owned by me and remain there after exiting from the container instance.</p><h3>Conclusions</h3><p>You now have an up-to-date personal Workstation docker configuration with GPU acceleration.</p><p>I hope you find this to as useful as I have!</p><p><strong>Happy computing! — dbk @dbkinghorn</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/200/0*ymvPFQVbKgTyVH1q" /><figcaption>Dr Kinghorn is the Scientific Computing advisor at Puget Systems <a href="https://www.pugetsystems.com/">https://www.pugetsystems.com/</a></figcaption></figure><p><em>Originally published at </em><a href="https://www.pugetsystems.com/labs/hpc/Workstation-Setup-for-Docker-with-the-New-NVIDIA-Container-Toolkit-nvidia-docker2-is-deprecated-1568/"><em>https://www.pugetsystems.com</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2243231d48c6" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[10 million matrix operations in the same time as 10 using PyTorch on a GPU]]></title>
            <link>https://medium.com/@dkinghorn/10-million-matrix-operations-in-the-same-time-as-10-using-pytorch-on-a-gpu-4df23fb8bd3?source=rss-67d0baf520ea------2</link>
            <guid isPermaLink="false">https://medium.com/p/4df23fb8bd3</guid>
            <category><![CDATA[science]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[mathematics]]></category>
            <dc:creator><![CDATA[Don Kinghorn]]></dc:creator>
            <pubDate>Tue, 11 Sep 2018 19:06:03 GMT</pubDate>
            <atom:updated>2018-09-11T19:06:03.097Z</atom:updated>
            <content:encoded><![CDATA[<h3>Constant-time scaling for batched tensor operations on GPU</h3><p>I recently discovered that some algorithms (batched) can run in constant-time on a GPU. That means, it takes the same amount of time to run a batch of 10 matrix operation as it does to do 10 million. The scaling is only limited by the available GPU memory.</p><blockquote>In over 20 years of doing scientific computing I have never seen scaling like this on any compute device! Constant-time out to the full memory availability on the GPU. Not linear or even super scaling, but constant-time scaling. I’m talking milliseconds! And, it was easy to do in PyTorch.</blockquote><p>I was working on optimizing the performance of some quantum mechanics code and needed to do a matrix decomposition (Cholesky) on millions of small matrices. I had been using a loop over some standard library routine. This scaled “OK” on CPU cores but when I ran this code on a GPU the performance was bad. <strong>I had to get rid of the loops!</strong></p><p>I am using the PyTorch framework as my scientific computing tool. What I am doing is a “non-standard use”, but it shouldn’t be! PyTorch is a newer Machine Learning/AI framework that is getting a lot of traction as a simple to use Python library for developing Deep neural network algorithms …things like that mostly, and, it is great for that use. However, the core functionality of PyTorch makes a very useful platform for general scientific/numerical computing. I’m making good use of tensor data structures, automatic gradients and simple code execution on GPU. PyTorch is nearly as easy to use as the Python workhorse “numpy”. In fact it is mostly API compatible with numpy. If you haven’t tried PyTorch then I highly recommend it.</p><h4><strong>To appreciate what constant-time scaling means look at this plot.</strong></h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/623/1*VIvQ-yWaUi5dyTMkAznFmA.png" /></figure><p>Those results are from my batched Cholesky decomposition code running on a Intel Xeon-W 2175 14-core CPU and on an NVIDIA Titan V GPU (both using double precision a.k.a. FP64, and both with full utilization of the hardware). The CPU performance for the “batched” code is very good and scales linearly. It’s about 10 times faster than doing loops. The same code on the GPU is blazing fast and scales in constant-time.</p><blockquote>For 10 million matrices the CPU took 3.6 seconds and the GPU took 0.0019 seconds. 1900 times faster.</blockquote><p>These are small matrices but they are around the sizes I need in my quantum mechanics code. This scaling relation still holds for 100 x 100 matrices but that uses a lot more memory so I can’t do the promised 10 million matrices with that size. For matrices larger than 100 x 100 loops over an optimized library call in MKL(CPU) or MAGMA(GPU) becomes more efficient than my batched version.</p><h3>Lets take a look at the PyTorch code to do the Cholesky matrix factorization</h3><p>The Cholesky decomposition algorithm is not that difficult. Have a l<a href="https://en.wikipedia.org/wiki/Cholesky_decomposition">ook at the Wikipedia page.</a> You can work it out with pencil and paper in a few minutes.</p><h4>Matrix version of Cholesky decomposition (in PyTorch)</h4><p>[ Note: I am not doing any input “sanity” checking in this code. Also note: I am using “th” as short for “torch” i.e. I use the Python line import torch as th ]</p><pre># Matrix Cholesky decomp<br>def matrix_cholesky(A):<br>    L = th.zeros_like(A)</pre><pre>for i in range(A.shape[-1]):<br>        for j in range(i+1):<br>            s = 0.0<br>            for k in range(j):<br>                s = s + L[i,k] * L[j,k]</pre><pre>L[i,j] = th.sqrt(A[i,i] - s) if (i == j) else \<br>                      (1.0 / L[j,j] * (A[i,j] - s))<br>    return L</pre><h3>Batched Tensor version of Cholesky decomposition (in PyTorch)</h3><p>To extend this algorithm to a batched tensor version consider the following diagram,</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TxcUV7oFeiONFZd6ee9QdQ.png" /></figure><p>Think of the large block as a stack of “m” “n x n” matrices. Then the “[1,1]” element of the stack becomes the vector represented by the small block. The algorithm I presented above only acts on one matrix in the stack. We can extend that algorithm to operate on the entire stack of matrices all at once. And, it’s easy!</p><pre>def cholesky(A):<br>    L = th.zeros_like(A)</pre><pre>for i in range(A.shape[-1]):<br>        for j in range(i+1):<br>            s = 0.0<br>            for k in range(j):<br>                s = s + L[...,i,k].clone() * L[...,j,k].clone()</pre><pre>L[...,i,j] = th.sqrt(A[...,i,i] - s) if (i == j) else \<br>                      (1.0 / L[...,j,j].clone() * (A[...,i,j] - s))<br>    return L</pre><p>This is nearly the same as the matrix version. The difference is that I added this “wild-card” indexing L[…, i,j]. the “…” means any higher dimensions of the tensor. The last 2 indices refer to the matrices. I used a “stack” to conceptualize the higher dimension but you could have more dimensions. For example if “…” represented 2 indices then this would be “tiling” instead of stacking.</p><p>The other thing in this code that looks different is that I added “.clone()” in a few places. That is to make the code usable with auto-gradients. This is because the PyTorch autograd code doesn’t work if there are “in-place” operations. The “clone()” makes a copy of the memory that is safe for autograd.</p><h4>More details …</h4><p>I have a blog post up at Puget Systems describing this batched Cholesky in detail with full working code that you could cut and paste into a Jupyter notebook to play with it yourself.</p><p><a href="https://www.pugetsystems.com/labs/hpc/PyTorch-for-Scientific-Computing---Quantum-Mechanics-Example-Part-3-Code-Optimizations---Batched-Matrix-Operations-Cholesky-Decomposition-and-Inverse-1225/"><strong><em>PyTorch for Scientific Computing — Quantum Mechanics Example Part 3) Code Optimizations — Batched Matrix Operations, Cholesky Decomposition and Inverse</em></strong></a></p><p>The first post in that series presents the quantum mechanics problem that I’m coding up.</p><p><a href="https://www.pugetsystems.com/labs/hpc/Doing-Quantum-Mechanics-with-a-Machine-Learning-Framework-PyTorch-and-Correlated-Gaussian-Wavefunctions-Part-1-Introduction-1207/"><strong><em>Doing Quantum Mechanics with a Machine Learning Framework: PyTorch and Correlated Gaussian Wavefunctions: Part 1) Introduction</em></strong></a></p><p>The second post in that series presents a naive implementation of the math that I describe in the first post. It presents a full working version of the code done in a very straight forward way.</p><p><a href="https://www.pugetsystems.com/labs/hpc/PyTorch-for-Scientific-Computing---Quantum-Mechanics-Example-Part-2-Program-Before-Code-Optimizations-1222/"><strong><em>PyTorch for Scientific Computing — Quantum Mechanics Example Part 2) Program Before Code Optimizations</em></strong></a></p><p>I have optimized that code using batched tensor operation to achieve a 15000 fold speedup on GPU. In the next post in that series I will be presenting the optimized code. Expect to see that in a week or so.</p><p><strong>Happy computing! — dbk</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4df23fb8bd3" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Should You Learn to Program with Python]]></title>
            <link>https://medium.com/@dkinghorn/should-you-learn-to-program-with-python-bc05ff70ed58?source=rss-67d0baf520ea------2</link>
            <guid isPermaLink="false">https://medium.com/p/bc05ff70ed58</guid>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Don Kinghorn]]></dc:creator>
            <pubDate>Thu, 06 Sep 2018 19:09:12 GMT</pubDate>
            <atom:updated>2018-09-06T19:09:12.456Z</atom:updated>
            <content:encoded><![CDATA[<p><strong>Read this article at </strong><a href="https://www.pugetsystems.com/guides/905"><strong>https://www.pugetsystems.com/guides/905</strong></a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/180/0*YomBbNC5uvVKtUq3" /></figure><p>Python, Python,Python … I have seen Python mentioned more in past year than any time since it’s creation. You could make a good argument that it is one of the most important programming languages today. It has an enormous number of uses in general and specifically,it is very compelling to consider using it for Data Analytics and Machine Learning since it has some excellent tools and API’s in that domain. Following is a bit of the Lore of Python and arguments for why you would want to consider using it.</p><h3>A Brief History of Python</h3><p>I think the following <a href="https://www.python.org/doc/essays/foreword/">quote from Guido van Rossum</a>says a lot about him and hints at why Python is a great programming language.</p><blockquote><em>…in December 1989, I was looking for a “hobby” programming project that would keep me occupied during the week around Christmas. My office … would be closed, but I had a home computer, and not much else on my hands. I decided to write an interpreter for the new scripting language I had been thinking about lately: a descendant of </em><a href="https://en.wikipedia.org/wiki/ABC_%28programming_language%29"><em>ABC</em></a><em> that would appeal to </em><a href="https://en.wikipedia.org/wiki/Unix"><em>Unix</em></a><em>/</em><a href="https://en.wikipedia.org/wiki/C_%28programming_language%29"><em>C</em></a><em> </em><a href="https://en.wikipedia.org/wiki/Hacker_%28programmer_subculture%29"><em>hackers</em></a><em>. I chose Python as a working title for the project, being in a slightly irreverent mood (and a big fan of </em><a href="https://en.wikipedia.org/wiki/Monty_Python%27s_Flying_Circus">Monty Python’s Flying Circus</a><em>).</em></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/200/0*bN4PaQSzqjNLIFlh" /></figure><p>Guido van Rossum is the, happily accepted, <a href="https://en.wikipedia.org/wiki/Benevolent_dictator_for_life"><em>benevolent dictator for life</em></a> (BDFL) of Python. He is one of those rare individuals that has both the intellect and personality to keep a project like Python from becoming a “<a href="https://www.google.com/search?client=ubuntu&amp;channel=fs&amp;q=monty+python+dead+parrot&amp;ie=utf-8&amp;oe=utf-8">Dead Parrot</a>” ( That link is to a classic skit, what can I say, I’m a Monty Python fan too :-).</p><p>Guido recently “stepped down” from being BDFL … sort of … he still is really, in spirit at least. He is passing the torch on to the wonderful community that has built up over the years and is not being as involved in day-to-day work of developing/maintaining/managing the language anymore.</p><blockquote>Should Guido have stepped down? Let’s have an argument; no he shouldn’t, yes he should, no he shouldn’t, yes he should, yes, no… this is not an argument! Yes it is, no it isn’t …</blockquote><p>I remember compiling Python from source in the early 1990’s, trying it out and thinking, OK this is kind of cool — A nice “C” like scripting language that runs in an interpreter loop. I then went back to using Perl and shell scripts for that sort of thing. By the time version 2 was released in 2000 Python had become an important general purpose programming language and was being widely used for critical applications including “system code” like RedHat’s Linux install application. By this time nearly every Linux and UNIX distribution had a Python install in the base OS packages. Since then Python has seen rapid, continuous growth and wide adoption. It runs on most operating systems including Linux, Windows, and MacOS. There is a lot of Python 2 code ( currently at version 2.7 ) running in important places. The version 2 branch should be supported until 2020. You can look at <a href="https://pythonclock.org/">pythonclock.org</a> for an unofficial countdown ( yes, it’s important enough to warrant that clock but 20 years is long enough).</p><p><strong>Why the concern about Python 2? Python 3 was released in 2008! </strong>Python 3 was an opportunity for van Rossum to make a decision that only a “BDFL” can make. Break some backward compatibility on a very successful project. Python 2 was solid but there were some inconsistencies and things that could just be better. So he did it. Python 3 is a better Python! [ One case where you might need to use Python 2 is if you have to support an “ancient” system OS that doesn’t have Python 3 and you have no control over that. Another case would be having to use some legacy version 2 code and you don’t have any control over that either. ] The best argument for Python 3 is probably this,</p><blockquote><a href="https://wiki.python.org/moin/Python2orPython3">Short version: Python 2.x is legacy, Python 3.x is the present and future of the language</a></blockquote><p>Python 3 is at version 3.6 as of this writing, it’s wonderful, and you should use it (or at least 3.4 or 3.5).</p><h3>Why should you Use/Learn Python?</h3><ul><li><strong>Python is easy to learn</strong><br> If you have used another programming language then Python is easy to pick up and start writing useful code with. If you haven’t used another language then, no, it wont actually be “easy”. Programming can be difficult to understand. However, Python is one of the most beginner friendly programming languages you could pick to start with.</li><li><strong>Python is “interactive”</strong> — It can use what is referred to as a <a href="https://en.wikipedia.org/wiki/Read%E2%80%93eval%E2%80%93print_loop">REPL ( Read-Eval-Print-Loop )</a>. This lets you interact directly from the Python “prompt”. You can execute commands one at a time interactively and see the results immediately. That is a great way to explore the language. You can use it like a powerful calculator.</li><li><strong>Python is “</strong><a href="https://en.wikipedia.org/wiki/Interpreted_language"><strong>interpreted</strong></a><strong>”</strong> — That’s as opposed to “<a href="https://en.wikipedia.org/wiki/Compiled_language">compiled</a>”. Python uses an interpreter, which is a program that reads your code and converts it to executable instructions for the hardware on-the-fly. A compiler takes a complete program source code and translates it into machine instructions and links it to other libraries of executable objects and creates a final program that can then executed directly in your operating system. With an interpreter you can write and run your code immediately. With a compiled language you have to go through series of sometimes complicated, steps, compiling and linking your code into an executable before you try to run it. With Python you get feedback immediately if you have made a mistake which makes its much easier to explore and learn.</li><li><strong>Python has a wealth of learning material</strong>. I did a quick search on <a href="https://www.safaribooksonline.com/">O’Reilly Safari Books Online</a> and got 6272 books, 59 live training links and 252 videos. That’s just on that one resource site. All of the popular online education sites have courses for learning Python. There is plenty resources to choose from for learning Python.</li><li><strong>Python has an active community</strong> — Python is popular! There are <a href="https://wiki.python.org/moin/LocalUserGroups">Python user groups</a> in every major city and most of them are kind to new learners. Python has a yearly conference <a href="https://us.pycon.org/2017/">PyCon</a> that attracts thousands attendees. Python was the 3rd most popular language on <a href="http://github.com/">GitHub</a>in 2016. I did a quick search and there were 390,000 repositories using Python on GitHub. ( there are 316 unique programming languages represented on GitHub… that’s kind of scary if you think about it! )</li></ul><p><strong>A few possible down sides when learning</strong></p><ul><li><strong>Python is not “statically typed”</strong>. ( A “type” is something like integer, float, string, etc.. ) That can be considered good or bad. It makes things easy because you don’t have to declare the type for a variable (good?) and a variable can be associated with different types during program execution (bad?). Python uses what is called “<a href="https://en.wikipedia.org/wiki/Duck_typing">duck typing</a>” i.e. “if it looks like duck, sounds like a duck … then it is a duck”. Variable types are inferred from context. For example if a = 2 (2 is an integer) and b = “2” (“2” is a string) then a + a = 4 but b + b = “22” ( in this case + does string concatenation ), a + b gives a type error, thankfully! Sometimes “weak typing” can be confusing and cause hard to find errors. Overall I think it is a good thing and it greatly simplifies code but sometimes a new user can get in trouble.</li><li><strong>Python uses indention to delineate block structure</strong>. That drives some people crazy! Most languages uses something like maybe, { }, to define the start and end of a code block. That gives you some versatility in how you layout your source code and makes start and end sections very clear. In Python that is mostly defined by indention. If you don’t get your indentation nesting right then your code will blow up or do something unintended. It’s annoying when you are editing and <a href="https://en.wikipedia.org/wiki/Code_refactoring">refactoring</a>code. It does result in clean an often more readable code.</li><li><strong>Python uses “C” like indexing</strong>. OK, this is just a personal rant. I have a mathematics background, to me the first element of the list [ 1, 2, 3 ] is the number 1. In Python (and most “C” based languages) 1 is the zero’th element, i.e. indexing starts at 0. In mathematics you usually call the first “thing”, “thing number 1” and you do mathematics based on that. Off-by-one and array indexing errors can be hard to debug. You do get used to 0 based indexing and it’s not really a problem, but it is sometimes annoying to me. Languages like <a href="https://www.mathworks.com/">Matlab</a> and <a href="http://julialang.org/">Julia</a> are a lot more comfortable for a mathematician in my opinion. [ <a href="http://julialang.org/">Julia</a> is my favorite “new” language and it works together with Python! ]</li></ul><h3>More good reasons to learn Python</h3><ul><li><strong>Python is versatile</strong><br> You can use multiple “styles” of programming with Python; <a href="https://en.wikipedia.org/wiki/Scripting_language">Scripting</a>, <a href="https://en.wikipedia.org/wiki/Procedural_programming">Procedural</a>, <a href="https://en.wikipedia.org/wiki/Object_oriented_programming">Object Oriented</a>, <a href="https://en.wikipedia.org/wiki/Functional_programming">Functional</a>. You can use Python for web programming, game programming, scientific programming, business/finance, embedded systems, operating system services, network programming, black-hat white-hat “hacking”, add-on scripting to other programs, GIS, etc.. It is a general purpose language with LOTS of available add-on modules.</li><li><strong>The “Standard Library” is expansive and useful and the “Package Index” is massive </strong><br> The phrase “<strong>Batteries Included</strong>” is used to describe the rich variety of packages in the “<a href="https://docs.python.org/3/library/">Standard Library</a>”. There are 37 section headings in the documentation for the standard library. Everything from multimedia support, internet protocols, html and XML processing, threading multiprocessing, cryptographic services, numeric and math support, OS system support, etc.. And that is the “standard” stuff. <strong>The </strong><a href="https://pypi.python.org/pypi"><strong>PYPI Python Package Index</strong></a><strong> has 98806 packages</strong>! (today) There is a Python module for just about everything you can think of to do with a programming language.</li><li><strong>There is a Python API for everything</strong><br> Well, maybe not everything … When developers make an <a href="https://en.wikipedia.org/wiki/Application_programming_interface">Application Programing Interface</a> for their programs, libraries or services it’s pretty likely that they, or someone else, will create a Python interface to make it easier to use and access. For just about any service that will allow a programmatic interface it’s likely that Python will be supported.</li><li><strong>You can get high performance with Python</strong><br> Traditionally Python has been considered a “slow” language because of it’s interpreted nature. It’s true that most algorithms written in pure Python will be much slower than if they had been implemented in a typical compiled language. However, that often doesn’t matter that much. Why? Because the packages that can be imported into a Python program can contain well optimized compiled libraries that link to high performance system libraries. A good example of that is the very popular “<a href="http://www.numpy.org/">NumPy</a>” package which is typically linked to <a href="https://software.intel.com/en-us/intel-mkl">Intel’s MKL ( highly optimized ) Math Kernel Library</a>. If you need to solve a large system of linear equations in Python don’t start writing “for” loops for matrix operations, just import NumPy and use its functions. There is also some support for parallel execution with threads, message passing and interfaces to access GPU accelerators for compute. These are advanced features but yes, you can use Python for high performance. There is also the consideration that it can take much less time to get working code running in Python. Even if that code is slower it may save a lot of time overall.</li><li><strong>Python is a great “glue” language</strong><br> “glue language” describes how Python is often used to tie together separate programs, libraries and API’s. Python can interface to so many different “computing objects” that it is great for creating hybrid functionality from programs that normally wouldn’t be able to talk to each other. You can combine C/C++, Fortran, and other code with Python in various ways too. Lots of languages will play nice with Python. It’s also not uncommon to use Python to create user interfaces or wrappers to programs that would otherwise be hard to work with.</li><li><strong>Python is a great operating system equalizer (Linux Windows MacOS)</strong><br> Python has modules in the standard library that allow you to make operating system calls in a unified way. That can be a big help in creating programs that will work on more than one operating system. It can effectively put a layer between the OS and your program that hides many of the differences in operating systems as long as there is similar functionality available. It’s not uncommon to find programs that run equally well on Linux, Windows and MacOS written in Python.</li><li><strong>Python is great for Data Analytics, Machine Learning and AI</strong><br> This is the real reason I’m looking at Python right now! There are some great tools for Data analytics and Machine Learning for Python. There are Python modules <a href="http://www.numpy.org/">NumPy</a>, <a href="http://pandas.pydata.org/">pandas</a>, <a href="https://www.scipy.org/">SciPy</a> <a href="http://www.statsmodels.org/stable/index.html">Statsmodels</a>, <a href="http://scikit-learn.org/stable/">Scikit-learn</a> <a href="http://shogun-toolbox.org/">Shogun</a>, <a href="http://bokeh.pydata.org/en/latest/">Bokeh</a>, <a href="http://matplotlib.org/">matplotlib</a>, and many others. There are interfaces for most important machine/deep learning frameworks like <a href="https://www.tensorflow.org/">TensorFlow</a>, <a href="http://caffe.berkeleyvision.org/">Caffe</a>, <a href="http://deeplearning.net/software/theano/">Theano</a>, <a href="http://mxnet.io/get_started/">mxnet</a>, etc.. Python also works well together with other popular languages for Machine Learning like “<a href="https://www.r-project.org/">R</a>”, <a href="http://julialang.org/">Julia</a>, <a href="https://www.java.com/en/">Java</a>, <a href="https://www.mathworks.com/">Matlab</a>, and <a href="https://www.lua.org/">Lua</a>. It’s hard to be involved with Machine Learning and not do at least something with Python.</li><li><strong>Python is easy to install and get started with</strong><br> Last but not least, Python is easy to install and get started with. This is pretty important since getting started with a programming environment can be challenging. This is another point in favor of Python, it’s not too hard to get started and there exists what is becoming a standard and recommended setup for Python development on all OS platforms.</li></ul><p>So there you have it. If you haven’t started with Python yet … well, get on with it then!</p><p><strong>Happy computing! — dbk</strong></p><p><strong>Tags:</strong> Python, Programming, Machine Learning</p><p><em>Originally published at </em><a href="https://www.pugetsystems.com/labs/hpc/Should-You-Learn-to-Program-with-Python-905/"><em>www.pugetsystems.com</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=bc05ff70ed58" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>