DL:深度学习开发环境搭建

zhangyuhu included in 计算机视觉

2023-01-30 3866 words 8 minutes

Contents

本文采用知识共享署名 4.0 国际许可协议进行许可，转载时请注明原文链接，图片在使用时请保留全部内容，可适当缩放并在引用处附上图片所在的文章链接。

硬件环境
深度学习开发环境搭建
测试一下GPU训练

硬件环境

处理器：AMD® Ryzen 5 3600 6-core processor × 12

显卡：NVIDIA Corporation TU104 [GeForce RTX 2060]

内存：16G DDR4

硬盘：1T SSD

系统：Ubuntu 20.04.1 LTS

深度学习开发环境搭建

更改系统软件源

备份原来的源：

`1`	`cp /etc/apt/sources.list /etc/apt/sources.list.bak`

将源的内容设置为阿里云镜像：

`1`	`sudo vim /etc/apt/sources.list`

内容改为：

deb http://mirrors.aliyun.com/ubuntu/ focal main restricted universe multiverse deb-src http://mirrors.aliyun.com/ubuntu/ focal main restricted universe multiverse deb http://mirrors.aliyun.com/ubuntu/ focal-security main restricted universe multiverse deb-src http://mirrors.aliyun.com/ubuntu/ focal-security main restricted universe multiverse deb http://mirrors.aliyun.com/ubuntu/ focal-updates main restricted universe multiverse deb-src http://mirrors.aliyun.com/ubuntu/ focal-updates main restricted universe multiverse deb http://mirrors.aliyun.com/ubuntu/ focal-proposed main restricted universe multiverse deb-src http://mirrors.aliyun.com/ubuntu/ focal-proposed main restricted universe multiverse deb http://mirrors.aliyun.com/ubuntu/ focal-backports main restricted universe multiverse deb-src http://mirrors.aliyun.com/ubuntu/ focal-backports main restricted universe multiverse

更新软件列表：

1
2

sudo apt update
sudo apt upgrade

安装Python和pip

Ubuntu系统默认自带python，有版本需求的话也可以自己安装一下

`1`	`sudo apt install python3sudo apt install python3-pip`

不管是不是自己安装的python，替换python的pip源建议是一定操作一下的，pip安装速度会快很多：

`1`	`cd ~mkdir .pip`

直接新建并编辑pip.conf：

`1`	`sudo vim ~/.pip/pip.conf`

改为以下内容（这里用的清华源，也可以试一下阿里、豆瓣等源）：

`1`	`[global]index-url = https://pypi.tuna.tsinghua.edu.cn/simple/ [install]trusted-host = pypi.tuna.tsinghua.edu.cn`

更改默认python版本，python目录默认链接的是python2，而现在基本都是用python3开发了

`1`	`sudo apt install python-is-python3`

安装Nvidia显卡驱动

打开软件和更新

选择安装Nvidia官方驱动（第二个是开源驱动）

禁止nouveau 驱动

`1`	`sudo gedit /etc/modprobe.d/blacklist.conf`

添加

blacklist nouveau
blacklist lbm-nouveau
options nouveau modeset=0
alias nouveau off
alias lbm-nouveau off

执行如下命令，更新系统，来禁用nouveau

`1`	`sudo update-initramfs -u`

重启完之后更新一下软件：
1 2

sudo apt update sudo apt upgrade

查看驱动

`1`	`nvidia-smi`

输出：

+-----------------------------------------------------------------------------+
| NVIDIA-SMI 450.102.04   Driver Version: 450.102.04   CUDA Version: 11.0     |
|-------------------------------+----------------------+----------------------+
| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |
| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |
|                               |                      |               MIG M. |
|===============================+======================+======================|
|   0  GeForce RTX 2060    Off  | 00000000:26:00.0  On |                  N/A |
|  0%   41C    P8     7W / 160W |    675MiB /  5931MiB |      7%      Default |
|                               |                      |                  N/A |
+-------------------------------+----------------------+----------------------+

+-----------------------------------------------------------------------------+
| Processes:                                                                  |
|  GPU   GI   CI        PID   Type   Process name                  GPU Memory |
|        ID   ID                                                   Usage      |
|=============================================================================|
|    0   N/A  N/A       908      G   /usr/lib/xorg/Xorg                 53MiB |
|    0   N/A  N/A      1457      G   /usr/lib/xorg/Xorg                219MiB |
|    0   N/A  N/A      1585      G   /usr/bin/gnome-shell              178MiB |
|    0   N/A  N/A     31707      G   ...cent\WeChat\WeChatApp.exe       10MiB |
|    0   N/A  N/A     37422      G   ...AAAAAAAA== --shared-files       36MiB |
|    0   N/A  N/A     42882      G   ...AAAAAAAAA= --shared-files       48MiB |
|    0   N/A  N/A     44445      G   ...AAAAAAAAA= --shared-files      104MiB |
|    0   N/A  N/A     45053      G   gnome-control-center                3MiB |
+-----------------------------------------------------------------------------+

安装CUDA

去官网下载cuda安装包：CUDA Toolkit 11.0 Download | NVIDIA Developer

运行下面的命令进行安装：

1
2
3

wget http://developer.download.nvidia.com/compute/cuda/11.0.2/local_installers/cuda_11.0.2_450.51.05_linux.run
chmod +x cuda_11.0.2_450.51.05_linux.run
sudo sh ./cuda_11.0.2_450.51.05_linux.run

根据上图提示需要配置环境变量：

`1`	`gedit ~/.bashrc`

再文件最后加入以下语句：

1
2
3

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

然后使其生效：

`1`	`source ~/.bashrc`

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

nvcc: NVIDIA (R) Cuda compiler driver
Copyright (c) 2005-2020 NVIDIA Corporation
Built on Thu_Jun_11_22:26:38_PDT_2020
Cuda compilation tools, release 11.0, V11.0.194
Build cuda_11.0_bu.TC445_37.28540450_0

也可以编译一个程序测试安装是否成功

找到 NVIDIA_CUDA-11.0_Samples 安装位置

`1`	`locate NVIDIA_CUDA-11.0_Samples`

1
2
3

cd NVIDIA_CUDA-11.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 2060"
  CUDA Driver Version / Runtime Version          11.0 / 11.0
  CUDA Capability Major/Minor version number:    7.5
  Total amount of global memory:                 5931 MBytes (6219563008 bytes)
  (30) Multiprocessors, ( 64) CUDA Cores/MP:     1920 CUDA Cores
  GPU Max Clock rate:                            1695 MHz (1.70 GHz)
  Memory Clock rate:                             7001 Mhz
  Memory Bus Width:                              192-bit
  L2 Cache Size:                                 3145728 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 Managed Memory:                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 / 38 / 0
  Compute Mode:
     < Default (multiple host threads can use ::cudaSetDevice() with device simultaneously) >

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

安装CuDNN

进入到CUDNN的下载官网： cuDNN Download | NVIDIA Developer，登陆下载

下载之后是一个压缩包，对它进行解压，命令如下：

`1`	`tar -xzvf cudnn-11.0-linux-x64-v8.0.5.39.tgz`

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

`1`	`sudo cp cuda/lib64/* /usr/local/cuda-11.0/lib64/ sudo cp cuda/include/* /usr/local/cuda-11.0/include/`

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

`1`	`cat /usr/local/cuda/include/cudnn_version.h \| grep CUDNN_MAJOR -A 2`

输出

#define CUDNN_MAJOR 8
#define CUDNN_MINOR 0
#define CUDNN_PATCHLEVEL 4
--
#define CUDNN_VERSION (CUDNN_MAJOR * 1000 + CUDNN_MINOR * 100 + CUDNN_PATCHLEVEL)

#endif /* CUDNN_VERSION_H */

安装Conda环境

什么是Conda

Conda是Python中用于管理包和环境的一大利器。使用Conda，我们还可以非常便利的使用数据科学相关的包。Conda可以帮助我们创建虚拟环境，从而方便的应用于多个项目中。

Anaconda实际上是一个软件的发行版，附带了Conda、python和150多个科学软件包及其相关的包。Conda是一个包和环境管理器。Anaconda是一个本身很大（大约500M），因为它附带了Python中最常见的数据科学包。如果您不需要所有的软件包，或者需要节省带宽或存储空间，那么也有miniconda，一个只包含conda和python的发行版。我们同样可以用Conda安装任何可用的软件包。

安装conda

在Anaconda官网下载Linux安装包：Anaconda | Individual Edition
运行下面的命令安装：

1
2

chmod +x Anaconda3-2020.11-Linux-x86_64.sh
./Anaconda3-2020.11-Linux-x86_64.sh

一路按ENTER确认，然后根据提示输入yes，这里我为了目录整洁不安装在默认路径，设置为下面的路径：/home/zyh/app/anaconda3

然后会询问你是否要初始化conda，输入yes确认，重开终端窗口之后，就可以看到conda环境可用了

conda 简单使用

**包管里 **

当我们成功安装anaconda后，我们可以很容易的使用conda来进行包管理。例如：

`1`	`conda install numpy`

除了每次安装一个包外，我们还可以一次性安装多个包，例如：

`1`	`conda install numpy pandas`

此外，我们还可以安装某个指定版本的包：

`1`	`conda install numpy=1.10`

Ps：使用conda安装指定包时，conda可以自动处理相关的包依赖。假设本身没有安装numpy时，若我们使用conda install scipy，则此时conda会自动安装numpy，因为scipy本身依赖numpy。

此外，conda还有一些其他的常用命令：

删除某个包：conda remove package_name
升级某个包：conda upgrade package_name
升级全部包：conda upgrade --all
查看包列表：conda list
模糊查询包：conda search 'keywords'

**环境管里 **

conda可以用于创建多个环境而从进行项目隔离。创建一个新的环境的格式如下：

`1`	`conda create -n env_name list_of_packages`

其中，-n后的参数env_name表示环境名称。接着可以跟着0个或多个包名称。

一个示例如下：

`1`	`conda create -n my_env numpy`

表示创建了一个新的环境：my_env。并同时在该环境中安装一个包：numpy。

此外，在创建环境时，我们可以指定Python的版本。例如：

`1`	`conda create -n my_env python=2.7`

其中，我们可以在conda命令中，增加python=x的信息用于指定Python的版本号。

此时，我们可以轻松的实现在一台机器上兼容Python2和Python3了。

当我们使用conda创建了一个新的环境后，可以使用如下命令进入该环境：

`1`	`conda activate env_name`

此时，当我们进行该环境后，可以看命令行中的引导符中已经提示出了当前所属的conda环境：

`1`	`conda list`

想要离开当前环境时，则只需要执行如下命令即可：

`1`	`conda deactivate`

环境的保存与加载

对于conda环境，其有着一个如下特性：环境共享。通过以配置文件的形式可以保存环境相关的全部信息。

我们可以使用如下命令将相关的环境信息保存在一个yaml文件中：

`1`	`conda env export > env.yaml`

此时，我们已经将当前环境相关的信息全部存储在env.yaml文件中。当我们希望在其他机器中创建一个相同的环境时，可以直接执行如下命令：

`1`	`conda env create -f env.yaml`

当你不记得在当前机器上存在哪些conda环境时，可以执行如下命令列出全部环境：

`1`	`conda env list`

此时，*号所在的行表示当前所属的环境。

当某个环境我们不再需要时，可以直接执行如下命令来删除该环境：

`1`	`conda env remove -n env_name`

测试一下GPU训练

本地Conda环境方式

用conda新建一个python3.8+pytorch1.7+cuda11.0的虚拟环境：

`1`	`conda create --name python_38-pytorch_1.7.0 python=3.8`

#
# To activate this environment, use
#
#     $ conda activate python_38-pytorch_1.7.0
#
# To deactivate an active environment, use
#
#     $ conda deactivate

进入环境

`1`	`conda activate python_38-pytorch_1.7.0`

检查一下是否切换到所需环境了

`1`	`which pip`

如果看到使用的确实是我们设置的环境目录中的pip的话说明就ok。

接下来在环境中安装pytorch，可以参考官网的安装命令：Start Locally | PyTorch

输入以下命令进行安装：

`1`	`pip install torch==1.7.0+cu110 torchvision==0.8.1+cu110 torchaudio===0.7.0 -f https://download.pytorch.org/whl/torch_stable.html`

环境配置就完成了，下面新建一个简单的测试脚本验证功能，新建mnist_train.py，内容如下：

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


class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(1, 20, 5, 1)
        self.conv2 = nn.Conv2d(20, 50, 5, 1)
        self.fc1 = nn.Linear(4 * 4 * 50, 500)
        self.fc2 = nn.Linear(500, 10)

    def forward(self, x):
        x = F.relu(self.conv1(x))
        x = F.max_pool2d(x, 2, 2)
        x = F.relu(self.conv2(x))
        x = F.max_pool2d(x, 2, 2)
        x = x.view(-1, 4 * 4 * 50)
        x = F.relu(self.fc1(x))
        x = self.fc2(x)
        return F.log_softmax(x, dim=1)


def train(args, 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 % args.log_interval == 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 test(args, model, device, test_loader):
    model.eval()
    test_loss = 0
    correct = 0
    with torch.no_grad():
        for data, target in test_loader:
            data, target = data.to(device), target.to(device)
            output = model(data)
            # sum up batch loss
            test_loss += F.nll_loss(output, target, reduction='sum').item()
            # get the index of the max log-probability
            pred = output.argmax(dim=1, keepdim=True)
            correct += pred.eq(target.view_as(pred)).sum().item()

    test_loss /= len(test_loader.dataset)

    print('\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format(
        test_loss, correct, len(test_loader.dataset),
        100. * correct / len(test_loader.dataset)))


def main():
    parser = argparse.ArgumentParser(description='PyTorch MNIST Example')
    parser.add_argument('--batch-size', type=int, default=64, metavar='N',
                        help='input batch size for training (default: 64)')
    parser.add_argument('--test-batch-size', type=int, default=1000, metavar='N',
                        help='input batch size for testing (default: 1000)')
    parser.add_argument('--epochs', type=int, default=10, metavar='N',
                        help='number of epochs to train (default: 10)')
    parser.add_argument('--lr', type=float, default=0.01, metavar='LR',
                        help='learning rate (default: 0.01)')
    parser.add_argument('--momentum', type=float, default=0.5, metavar='M',
                        help='SGD momentum (default: 0.5)')
    parser.add_argument('--no-cuda', action='store_true', default=False,
                        help='disables CUDA training')
    parser.add_argument('--seed', type=int, default=1, metavar='S',
                        help='random seed (default: 1)')
    parser.add_argument('--log-interval', type=int, default=10, metavar='N',
                        help='how many batches to wait before logging training status')
    parser.add_argument('--save-model', action='store_true', default=False,
                        help='For Saving the current Model')

    args = parser.parse_args()
    use_cuda = not args.no_cuda and torch.cuda.is_available()
    torch.manual_seed(args.seed)
    device = torch.device("cuda" if use_cuda else "cpu")
    kwargs = {'num_workers': 1, 'pin_memory': True} if use_cuda else {}
    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=args.batch_size, shuffle=True, **kwargs)
    test_loader = torch.utils.data.DataLoader(
        datasets.MNIST('./data', train=False, transform=transforms.Compose([
            transforms.ToTensor(),
            transforms.Normalize((0.1307,), (0.3081,))
        ])),
        batch_size=args.test_batch_size, shuffle=True, **kwargs)

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

    for epoch in range(1, args.epochs + 1):
        train(args, model, device, train_loader, optimizer, epoch)
        test(args, model, device, test_loader)

    if (args.save_model):
        torch.save(model.state_dict(), "mnist_cnn.pt")


if __name__ == '__main__':
    main()

运行脚本，正常的话就可以看到训练输出了：

参考

【保姆级教程】个人深度学习工作站配置指南

一文了解 conda 与 Python 的关系

Pytorch 之 MNIST 数据集实现