原文博客：Doi技术团队
连接地址：https://blog.doiduoyi.com/authors/1584446358138
初心：记录优秀的Doi技术团队学习经历html

前言

最近在学习PaddlePaddle在各个显卡驱动版本的安装和使用，因此同时也学习如何在Ubuntu安装和卸载CUDA和CUDNN，在学习过程当中，顺便记录学习过程。在供你们学习的同时，也在增强本身的记忆。本文章以卸载CUDA 8.0 和 CUDNN 7.05 为例，以安装CUDA 10.0 和 CUDNN 7.4.2 为例。python

安装显卡驱动

禁用nouveau驱动

sudo vim /etc/modprobe.d/blacklist.conf

在文本最后添加：linux

blacklist nouveau
options nouveau modeset=0

而后执行：web

sudo update-initramfs -u

重启后，执行如下命令，若是没有屏幕输出，说明禁用nouveau成功：vim

lsmod | grep nouveau

下载驱动

官网下载地址：https://www.nvidia.cn/Download/index.aspx?lang=cn ，根据本身显卡的状况下载对应版本的显卡驱动，好比笔者的显卡是RTX2070：
bash

下载完成以后会获得一个安装包，不一样版本文件名可能不同：app

NVIDIA-Linux-x86_64-410.93.run

卸载旧驱动

如下操做都须要在命令界面操做，执行如下快捷键进入命令界面，并登陆：ide

Ctrl-Alt+F1

执行如下命令禁用X-Window服务，不然没法安装显卡驱动：svg

sudo service lightdm stop

执行如下三条命令卸载原有显卡驱动：oop

sudo apt-get remove --purge nvidia*
sudo chmod +x NVIDIA-Linux-x86_64-410.93.run
sudo ./NVIDIA-Linux-x86_64-410.93.run --uninstall

安装新驱动

直接执行驱动文件便可安装新驱动，一直默认便可：

sudo ./NVIDIA-Linux-x86_64-410.93.run

执行如下命令启动X-Window服务

sudo service lightdm start

最后执行重启命令，重启系统便可：

reboot

注意： 若是系统重启以后出现重复登陆的状况，多数状况下都是安装了错误版本的显卡驱动。须要下载对应自己机器安装的显卡版本。

卸载CUDA

为何一开始我就要卸载CUDA呢，这是由于笔者是换了显卡RTX2070，本来就安装了CUDA 8.0 和 CUDNN 7.0.5不可以正常使用，笔者须要安装CUDA 10.0 和 CUDNN 7.4.2，因此要先卸载原来的CUDA。注意如下的命令都是在root用户下操做的。

卸载CUDA很简单，一条命令就能够了，主要执行的是CUDA自带的卸载脚本，读者要根据本身的cuda版本找到卸载脚本：

sudo /usr/local/cuda-8.0/bin/uninstall_cuda_8.0.pl

卸载以后，还有一些残留的文件夹，以前安装的是CUDA 8.0。能够一并删除：

sudo rm -rf /usr/local/cuda-8.0/

这样就算卸载完了CUDA。

安装CUDA

安装的CUDA和CUDNN版本：

CUDA 10.0
CUDNN 7.4.2

接下来的安装步骤都是在root用户下操做的。

下载和安装CUDA

咱们能够在官网：CUDA10下载页面，
下载符合本身系统版本的CUDA。页面以下：

下载完成以后，给文件赋予执行权限：

chmod +x cuda_10.0.130_410.48_linux.run

执行安装包，开始安装：

./cuda_10.0.130_410.48_linux.run

开始安装以后，须要阅读说明，可使用Ctrl + C直接阅读完成，或者使用空格键慢慢阅读。而后进行配置，我这里说明一下：

（是否赞成条款，必须赞成才能继续安装）
accept/decline/quit: accept

（这里不要安装驱动，由于已经安装最新的驱动了，不然可能会安装旧版本的显卡驱动，致使重复登陆的状况）
Install NVIDIA Accelerated Graphics Driver for Linux-x86_64 410.48?
(y)es/(n)o/(q)uit: n

Install the CUDA 10.0 Toolkit?（是否安装CUDA 10 ，这里必需要安装）
(y)es/(n)o/(q)uit: y

Enter Toolkit Location（安装路径，使用默认，直接回车就行）
 [ default is /usr/local/cuda-10.0 ]:  

Do you want to install a symbolic link at /usr/local/cuda?（赞成建立软连接）
(y)es/(n)o/(q)uit: y

Install the CUDA 10.0 Samples?（不用安装测试，自己就有了）
(y)es/(n)o/(q)uit: n

Installing the CUDA Toolkit in /usr/local/cuda-10.0 ...（开始安装）

安装完成以后，能够配置他们的环境变量，在vim ~/.bashrc的最后加上如下配置信息：

export CUDA_HOME=/usr/local/cuda-10.0
export LD_LIBRARY_PATH=${CUDA_HOME}/lib64
export PATH=${CUDA_HOME}/bin:${PATH}

最后使用命令source ~/.bashrc使它生效。

可使用命令nvcc -V查看安装的版本信息：

test@test:~$ nvcc -V
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

测试安装是否成功

执行如下几条命令：

cd /usr/local/cuda-10.0/samples/1_Utilities/deviceQuery
make
./deviceQuery

正常状况下输出：

./deviceQuery Starting...

 CUDA Device Query (Runtime API) version (CUDART static linking)

Detected 1 CUDA Capable device(s)

Device 0: "GeForce RTX 2070"
  CUDA Driver Version / Runtime Version          10.0 / 10.0
  CUDA Capability Major/Minor version number:    7.5
  Total amount of global memory:                 7950 MBytes (8335982592 bytes)
  (36) Multiprocessors, ( 64) CUDA Cores/MP:     2304 CUDA Cores
  GPU Max Clock rate:                            1620 MHz (1.62 GHz)
  Memory Clock rate:                             7001 Mhz
  Memory Bus Width:                              256-bit
  L2 Cache Size:                                 4194304 bytes
  Maximum Texture Dimension Size (x,y,z)         1D=(131072), 2D=(131072, 65536), 3D=(16384, 16384, 16384)
  Maximum Layered 1D Texture Size, (num) layers  1D=(32768), 2048 layers
  Maximum Layered 2D Texture Size, (num) layers  2D=(32768, 32768), 2048 layers
  Total amount of constant memory:               65536 bytes
  Total amount of shared memory per block:       49152 bytes
  Total number of registers available per block: 65536
  Warp size:                                     32
  Maximum number of threads per multiprocessor:  1024
  Maximum number of threads per block:           1024
  Max dimension size of a thread block (x,y,z): (1024, 1024, 64)
  Max dimension size of a grid size    (x,y,z): (2147483647, 65535, 65535)
  Maximum memory pitch:                          2147483647 bytes
  Texture alignment:                             512 bytes
  Concurrent copy and kernel execution:          Yes with 3 copy engine(s)
  Run time limit on kernels:                     Yes
  Integrated GPU sharing Host Memory:            No
  Support host page-locked memory mapping:       Yes
  Alignment requirement for Surfaces:            Yes
  Device has ECC support:                        Disabled
  Device supports Unified Addressing (UVA):      Yes
  Device supports Compute Preemption:            Yes
  Supports Cooperative Kernel Launch:            Yes
  Supports MultiDevice Co-op Kernel Launch:      Yes
  Device PCI Domain ID / Bus ID / location ID:   0 / 1 / 0
  Compute Mode:
     < Default (multiple host threads can use ::cudaSetDevice() with device simultaneously) >

deviceQuery, CUDA Driver = CUDART, CUDA Driver Version = 10.0, CUDA Runtime Version = 10.0, NumDevs = 1
Result = PASS

下载和安装CUDNN

进入到CUDNN的下载官网：https://developer.nvidia.com/rdp/cudnn-download ，然点击Download开始选择下载版本，固然在下载以前还有登陆，选择版本界面以下，咱们选择cuDNN Library for Linux：

下载以后是一个压缩包，以下：

cudnn-10.0-linux-x64-v7.4.2.24.tgz

而后对它进行解压，命令以下：

tar -zxvf cudnn-10.0-linux-x64-v7.4.2.24.tgz

解压以后能够获得如下文件：

cuda/include/cudnn.h
cuda/NVIDIA_SLA_cuDNN_Support.txt
cuda/lib64/libcudnn.so
cuda/lib64/libcudnn.so.7
cuda/lib64/libcudnn.so.7.4.2
cuda/lib64/libcudnn_static.a

使用如下两条命令复制这些文件到CUDA目录下：

cp cuda/lib64/* /usr/local/cuda-10.0/lib64/
cp cuda/include/* /usr/local/cuda-10.0/include/

拷贝完成以后，可使用如下命令查看CUDNN的版本信息：

cat /usr/local/cuda/include/cudnn.h | grep CUDNN_MAJOR -A 2

测试安装结果

到这里就已经完成了CUDA 10 和 CUDNN 7.4.2 的安装。能够安装对应的Pytorch的GPU版本测试是否能够正常使用了。安装以下：

pip3 install https://download.pytorch.org/whl/cu100/torch-1.0.0-cp35-cp35m-linux_x86_64.whl
pip3 install torchvision

而后使用如下的程序测试安装状况：

import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
import torch.backends.cudnn as cudnn
from torchvision import datasets, transforms


class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(1, 10, kernel_size=5)
        self.conv2 = nn.Conv2d(10, 20, kernel_size=5)
        self.conv2_drop = nn.Dropout2d()
        self.fc1 = nn.Linear(320, 50)
        self.fc2 = nn.Linear(50, 10)

    def forward(self, x):
        x = F.relu(F.max_pool2d(self.conv1(x), 2))
        x = F.relu(F.max_pool2d(self.conv2_drop(self.conv2(x)), 2))
        x = x.view(-1, 320)
        x = F.relu(self.fc1(x))
        x = F.dropout(x, training=self.training)
        x = self.fc2(x)
        return F.log_softmax(x, dim=1)


def train(model, device, train_loader, optimizer, epoch):
    model.train()
    for batch_idx, (data, target) in enumerate(train_loader):
        data, target = data.to(device), target.to(device)
        optimizer.zero_grad()
        output = model(data)
        loss = F.nll_loss(output, target)
        loss.backward()
        optimizer.step()
        if batch_idx % 10 == 0:
            print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
                epoch, batch_idx * len(data), len(train_loader.dataset),
                       100. * batch_idx / len(train_loader), loss.item()))

def main():
    cudnn.benchmark = True
    torch.manual_seed(1)
    device = torch.device("cuda")
    kwargs = { 
 
   'num_workers': 1, 'pin_memory': True}
    train_loader = torch.utils.data.DataLoader(
        datasets.MNIST('../data', train=True, download=True,
                       transform=transforms.Compose([
                           transforms.ToTensor(),
                           transforms.Normalize((0.1307,), (0.3081,))
                       ])),
        batch_size=64, shuffle=True, **kwargs)

    model = Net().to(device)
    optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.5)

    for epoch in range(1, 11):
        train(model, device, train_loader, optimizer, epoch)


if __name__ == '__main__':
    main()

若是正常输出一下如下信息，证实已经安装成了：

Train Epoch: 1 [0/60000 (0%)]	Loss: 2.365850
Train Epoch: 1 [640/60000 (1%)]	Loss: 2.305295
Train Epoch: 1 [1280/60000 (2%)]	Loss: 2.301407
Train Epoch: 1 [1920/60000 (3%)]	Loss: 2.316538
Train Epoch: 1 [2560/60000 (4%)]	Loss: 2.255809
Train Epoch: 1 [3200/60000 (5%)]	Loss: 2.224511
Train Epoch: 1 [3840/60000 (6%)]	Loss: 2.216569
Train Epoch: 1 [4480/60000 (7%)]	Loss: 2.181396

参考资料

https://developer.nvidia.com
https://www.cnblogs.com/luofeel/p/8654964.html

<p>深度学习与PyTorch实战</p> </div> <p/>

本文同步分享在博客“夜雨飘零1”（CSDN）。
若有侵权，请联系 support@oschina.cn 删除。
本文参与“OSC源创计划”，欢迎正在阅读的你也加入，一块儿分享。

Ubuntu安装和卸载CUDA和CUDNN

目录

文章目录

前言