深度学习-0-环境配置

本文最后更新于：2021年8月2日 晚上

创作声明：主要内容为互联网内容整合，其中关于开发环境配置主要参考为知乎稚辉的专栏教程：https://zhuanlan.zhihu.com/p/336429888

硬件篇

建议Intel+NVIDIA
作为生产力工具考虑到软件库的兼容性问题，决定选择Intel+NVIDIA平台。

1
2
3
4
5
有钱: 
3090+10代i9+64g内存+2T固态+12T机械
  GPU方面3090，24G的显存跟TITAN RTX持平了（价格却只要一半）...硬盘的设计是这样的：1T的NVME固态做系统盘，12T的机械盘作为数据集仓库，另外一个1T SATA固态作为训练时的数据集缓存，因为IO读写速度也是会影响训练效率的，所以相比于直接从机械盘里面读取数据，加一块SSD做cache效果会好很多。
没钱: 
3060+11代i5+32g内存+512g固态+1T机械

系统篇

工作站配置为Windows+Ubuntu双系统

  • 安装windows系统
    建议使用微PE工具进行安装。（网上有许多相关教程）
  • 安装Ubuntu系统
  1. 在官网下载Ubuntu镜像：Ubuntu 20.04.1 LTS Destop image版本，得到.iso镜像文件，在rufus下载rufus，选择安装系统镜像，分区选择GPT，目标系统UEFI，之后点击开始，等待进度条走完，然后点击[关闭]，弹出U盘就ok了。
  2. 重启电脑，启动时连续按F2，进入BIOS，关闭安全启动(不同主板设置不同，请自行查找相关资料进行修改)。
  3. 在BIOS选择U盘启动项进入临时的Ubuntu系统，在图形界面中选择Install Ubuntu，所有配置都可以使用默认的，改一下用户名和密码即可。 这里建议使用英文作为默认语言，避免给自己日后开发找麻烦，安装过程中会联网下载一些软件包更新，可以直接点skip掉，在安装好系统之后再换源手动更新更快。
  4. 关于分区（建议系统默认安装自动分区，在Ubuntu分区时选择“向导──使用最大的连续空闲空间”）
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    手动分区：
    一共分出5个系统分区。
    (1). 设置efi引导
    因为是u盘的uefi启动，因此设置一个efi引导项。
    具体参数：
    大小: 500到1024mb即可
    （视自身的存储空间而定）
    新分区的类型： 逻辑分区
    新分区的位置： 空间起始位置
    用于： EFI系统分区
    (2).swap
    swap用作虚拟内存，根据自身的物理内存决定。
    如果物理内存在8G以下，则swap设置为物理内存一样的大小，如果超过8G，则一般设置为8G大小的虚拟内存就足够了。根据自身的使用需求，也可以适当增大swap大小。
    我的电脑用了两个8g的内存条，因此大小设置为了16g*1024=16384MB。
    具体参数：
    大小: （视自身的物理内存而定）
    新分区的类型： 主分区
    新分区的位置： 空间起始位置
    用于： 交换空间
    (3). 挂载点/
    主要用来存放ubuntu系统文件。有固态硬盘的可以安在固态盘中。
    具体参数：
    大小: 100G
    （视自身的存储空间而定）
    新分区的类型： 逻辑分区
    新分区的位置： 空间起始位置
    用于： Ext4日志文件系统
    挂载点： /
    (4).挂载点/home
    存放用户文件。这个分区尽量设置大一些，因为我安装了机械盘，因此分配了300g的存储空间给它。
    具体参数：
    大小: 300G
    （视自身的存储空间而定）
    新分区的类型： 逻辑分区
    新分区的位置： 空间起始位置
    用于： Ext4日志文件系统
    挂载点： /home
    分区完成之后，设置安装启动器设备，注意，这里选择刚刚分出来的efi分区，具体的设备号最好再三对照表格中的数据。
    完成后，会弹出一个确认界面，再一次确认是否分区正确。
  5. 进入系统后设置一下root账户密码：
    1
    sudo passwd root
    同时为了避免每次sudo都要输入密码，这里配置一下visudo：
    1
    sudo visudo
    在文件最后加上一句（改为自己的用户名）：
    1
    user ALL=(ALL) NOPASSWD: ALL
  6. 替换软件源
    提升后续安装软件时的速度
    备份原来的源：
    1
    cp /etc/apt/sources.list /etc/apt/sources.list.bak
    将源的内容设置为阿里云镜像：
    1
    sudo vim /etc/apt/sources.list
    内容改为：(自行查找vim基本指令)
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    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
  7. Ubuntu系统默认自带python，有版本需求的话也可以自己安装一下（不安装也行因为后面会安装conda环境）： 
    1
    2
    sudo apt install python3
    sudo apt install python3-pip
    替换python的pip源建议是一定操作一下的，pip安装速度会快很多：
    1
    2
    cd ~
    mkdir .pip
    直接新建并编辑pip.conf：
    1
    sudo vim ~/.pip/pip.conf
    改为以下内容（这里用的清华源，也可以试一下阿里、豆瓣等源）：
    1
    2
    3
    4
    [global]
    index-url = https://pypi.tuna.tsinghua.edu.cn/simple/ 
    [install]
    trusted-host = pypi.tuna.tsinghua.edu.cn
    更改默认python版本，python目录默认链接的是python2，而现在基本都是用python3开发了，每次都输入python3很麻烦所以这里直接更换默认的python命令链接。
    把原来的python软链接删掉：
    1
    sudo rm /usr/bin/python
    新建一个软链接：
    1
    2
    sudo ln -s /usr/bin/python3 /usr/bin/python
    sudo ln -s /usr/bin/pip3 /usr/bin/pip
    现在输入python就会进入python3环境了。

    环境搭建

    远程开发

安装SSH：

1
sudo apt install ssh

会自动安装好很多依赖包并启动服务，完成之后用XShell等软件就可以SSH登录服务器了。
安装xrdp：
Xrdp 是一个微软远程桌面协议（RDP）的开源实现，它允许我们通过图形界面控制远程系统。这里使用RDP而不是VNC作为远程桌面，是因为Windows自带的远程桌面连接软件就可以连接很方便，另外RDP在Windows下的体验非常好，包括速度很快（因为压缩方案做得比较好），可以直接在主机和远程桌面之间复制粘贴等等。
安装过程如下：

1
sudo apt install xrdp

安装完成xrdp 服务将会自动启动，可以输入下面的命令验证它：

1
sudo systemctl status xrdp

默认情况下，xrdp 使用/etc/ssl/private/ssl-cert-snakeoil.key，它仅仅对ssl-cert用户组成语可读，所以需要运行下面的命令，将xrdp用户添加到这个用户组：

1
2
sudo adduser xrdp ssl-cert  
sudo systemctl restart xrdp

安装frp进行内网穿透

前面介绍的SSH和远程桌面都是需要在局域网下通过IP地址进行连接的，而我们配置一台服务器最重要的诉求，应该是可以随时随地去访问服务器。

那在家里面，网络运营商提供的网络服务通过路由器路由到各个设备，此时路由器会同时具备内网地址（路由器之内，局域网，LAN，也就是192.168.x.x）和外网地址（路由器之外，互联网，WAN）。但是其实这个WAN口的IP并不是真正的“公网IP”，而时经过了多层的NAT转换之后的地址，外网的设备是不能通过这个地址访问到路由器的。这个问题的原因是ipv4地址池紧张，如果运营商给每家的路由器都安排一个公网ip的话，那ip地址早就不够用了呀。

因此为了能让外网访问到我们局域网内的设备，就需要跟中国电信等运营商申请公网ip（现在能申请到的概率也已经不大了，而且即使申请到也不是所有端口都可以使用的），或者我们自己动手做一些操作来达到同样的目的。

使用frp之类的软件做反向代理来实现内网穿透，这个方案需要你有一台带公网IP的云服务器的，优点就是完全可控，自己想配置多少个端口的穿透都可以，速度跟你的云服务器带宽有关。
为什么需要多个端口？ 是因为不同应用占用的端口不同，比如我们的SSH走的是22号端口，而远程桌面的rdp走的是3389号端口，如果需要自建Web服务的话则是走80/443端口、想把工作站作为上外网的代理服务器的话会需要1080端口等等…所以用上面第二个方案显然会方便很多，而且云服务器也不贵，我在腾讯云上购买一年只要200左右。

如何安装配置frp：

frp分为frps（server）和frpc（client）两个包

前者安装到我们的云服务器上，后者安装在需要被外网访问到的各个设备上，这里就是指我们的深度学习工作站。
云服务器：
在frp下载适合你服务器系统的frp软件，我这里是用的是腾讯云64位Ubuntu18.04所以选择frp_0.34.3_linux_amd64.tar.gz，下好之后解压：

1
tar -zxvf frp_0.34.3_linux_amd64.tar.gz

我们需要编辑的文件是frps.ini :

内容改为：(#后面去掉)

1
2
3
4
5
6
7
[common]
bind_port = 7000 # frp服务的端口号，可以自己定
dashboard_port = 7500 # frp的web界面的端口号
dashboard_user = user # web界面的登陆账户，自己修改
dashboard_pwd = pass # web界面的登陆密码，自己修改
authentication_method = token
token = xxxxx # frp客户端连接时的密码，自己修改

保存配置后，使用该命令启动：

1
./frps -c ./frps.ini

在浏览器输入 [云服务器的公网ip]:7500 (不用带[])即可访问到 frp的web管理界面。

注意，可能需要去云服务器控制台配置安全组规则开放以上涉及到的端口，否则无法访问。

本地的深度学习服务器端：
下载相应版本的frpc软件包（跟刚刚一样的）：这里选amd64的，下好之后解压到一个临时文件夹。
修改frpc.ini配置文件，内容如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
[common]
server_addr = xx.xx.xx.xx # 你的云服务器的公网ip
authentication_method = token
token = xxxxx # 刚刚配置的frp连接密码 
server_port = 7000 # 刚刚配置的frp服务端口

[Fusion-ssh]
type = tcp
local_ip = 127.0.0.1
local_port = 22
remote_port = 20022
​
[Fusion-rdp]
type = tcp
local_ip = 127.0.0.1
local_port = 3389
remote_port = 23389

通过上面的脚本就可以把对于云服务器特定端口的访问给重定向到本地服务器的某个端口了，简单地讲就是：假如我用SSH客户端访问 [云服务器ip]:20022，就可以经过反向代理直接访问到[本地的训练服务器ip]:20022；同理需要连接远程桌面的话，只需要访问[云服务器ip]:23389就可以了。
添加开机自动启动的脚本，新建一个文件：
/etc/systemd/system/frpc.service，注意修改其中的路径
内容： 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
[Fusion]
Description=Frp Server Daemon
After=syslog.target network.target
Wants=network.target

[Service]
Type=simple
ExecStart=/usr/local/bin/frp/frpc -c /usr/local/bin/frp/frpc.ini # 修改为你的frp实际安装目录
ExecStop=/usr/bin/killall frpc
#启动失败1分钟后再次启动
RestartSec=1min
KillMode=control-group
#重启控制：总是重启
Restart=always
​
[Install]
WantedBy=multi-user.target

然后执行以下命令启用脚本：

1
2
sudo systemctl enable frpc.service
sudo systemctl start frpc.service

通过下面的命令查看服务状态，如果是running的话就说明可以了：

1
sudo systemctl status frpc.service

这里顺便提一下，按照习惯一般把上面的frp软件解压防止在/usr/local/bin目录下。Linux 的软件安装目录是也是有讲究的，理解这一点，在对系统管理是有益的

1
2
3
4
5
6
7
/usr：系统级的目录，可以理解为C:/Windows/
/usr/lib：可以理解为C:/Windows/System32
/usr/local：用户级的程序目录，可以理解为C:/Progrem Files/，用户自己编译的软件默认会安装到这个目录下
/opt：用户级的程序目录，可以理解为D:/Software，opt有可选的意思，这里可以用于放置第三方大型软件（或游戏），当你不需要时，直接rm -rf掉即可。在硬盘容量不够时，也可将/opt单独挂载到其他磁盘上使用
源码放哪里？
/usr/src：系统级的源码目录
/usr/local/src：用户级的源码目录。

安装SAMBA服务
如果能把服务器上的磁盘直接挂载到我们使用的Windows个人PC上是不是很爽？
我们可以通过建立局域网SAMBA服务来实现这个效果：
安装samba 和samba-common-bin

1
sudo apt-get install samba samba-common-bin

配置/etc/samba/smb.conf文件

1
sudo nano /etc/samba/smb.conf

在最后一行后面加入：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 共享文件夹显示的名称
[home]
# 说明信息
comment = Fusion WorkStation Storage
# 可以访问的用户
valid users = sage,root
# 共享文件的路径
path = /home/sage/
# 可被其他人看到资源名称（非内容）
browseable = yes
# 可写
writable = yes
# 新建文件的权限为 664
create mask = 0664
# 新建目录的权限为 775
directory mask = 0775

可以把配置文件中你不需要的分享名称删除，例如 [homes], [printers] 等。
运行这个命令测试一下配置文件是否有错误，根据提示做相应修改：

1
testparm

添加登陆账户并创建密码
必须是 linux 已存在的用户：

1
sudo smbpasswd -a pi

然后重启服务即可：

1
sudo /etc/init.d/samba-ad-dc restart

接下来可以在Windows的网络中发现设备了：
但是可能会出现无法点开的情况，这里需要在Windows的凭据管理器中添加账户信息（开始菜单里搜索凭据管理器即可打开），点击添加Windows凭据，输入你的服务器名称和账户密码，接下来就可以点进去看到服务器上的文件了。 为了更加方便地进行文件交互，我们添加对应的磁盘到Windows资源管理器的此电脑中，选择刚刚服务器的网络路径即可添加。

GPU相关的驱动和环境

在安装显卡驱动前一定要到BIOS关闭安全启动！
系统自带的显卡驱动不是NVIDIA的，先删除这个驱动

1
sudo apt-get remove --purge nvidia*

NVIDIA驱动
最简单的方式是通过系统的软件与更新来安装：
进入系统的图形桌面，打开Software & Updates软件，可以看到标签栏有一个Additional Drivers：
选择第一个安装Nvidia官方驱动（第二个是开源驱动）即可，根据网络情况稍等大概十分钟，安装完重启服务器，重启完之后更新一下软件。

1
2
sudo apt update
sudo apt upgrade

这里会连带Nvidia的驱动一起升级一遍，更新到最新的驱动；更新完可能会出现nvidia-smi命令报错，再重启一下就解决了。
安装Cuda
去官网下载cuda安装包：cuda （根据实际情况选择）

运行下面的命令进行安装（换成自己的文件名）：

1
2
chmod +x cuda_11.0.2_450.51.05_linux.run
sudo sh ./cuda_11.0.2_450.51.05_linux.run

可能会报一个警告

前面已经卸载过旧版本了直接Continue就好。然后根据提示选择安装选项，注意不要勾选第一个安装显卡驱动的，因为之前已经安装过了。 安装完成后提示：

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

1
nano  ~/.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查看安装的版本信息，也可以编译一个程序测试安装是否成功，执行以下几条命令：

1
2
3
cd ~/Softwares/cuda/NVIDIA_CUDA-11.0_Samples/1_Utilities/deviceQuery
make
./deviceQuery

正常的话会有相应输出，打印显卡的信息。
安装CuDNN
进入到CuDNN的下载官网，点击Download开始选择下载版本，当然在下载之前还有登录，选择版本界面如下：

我们选择和之前cuda版本对应的cudnn版本：

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

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

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

1
2
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

可以看到版本信息如下，为8.0.5：

安装Conda环境
不同的训练框架和版本可能会需要不同的python版本相对应，而且有的包比如numpy也对版本有要求，所以比较优雅的方法是给每个配置建立一个虚拟的python环境，在需要的时候可以随时切换，而不需要的时候也能删除不浪费磁盘资源，那在这方面conda是做得最好的。

  1. 在Anaconda官网下载Linux版本安装包：Anaconda
  2. 运行下面的命令安装：
    1
    2
    chmod +x Anaconda3-2020.11-Linux-x86_64.sh
    ./Anaconda3-2020.11-Linux-x86_64.sh
    一路按ENTER确认，然后根据提示输入yes，这里我为了目录整洁不安装在默认路径，设置为下面的路径：/home/sage/Softwares/anaconda
    然后会询问你是否要初始化conda，输入yes确认，重开终端窗口之后，就可以看到conda环境可用了（base代表默认环境）：
    conda的使用方法网上搜一下有很多，这里就不赘述了。

安装Nvidia-Docker
Docker也是虚拟化环境的神器，前面说的conda虽然可以提供python的虚拟环境并方便地切换，但是有的时候我们的开发环境并不只是用到python，比如有的native库需要对应gcc版本的编译环境，或者进行交叉编译时要安装很多工具链等等。如果这些操作都在服务器本地上进行，那时间久了就会让服务器的文件系统非常杂乱，而且还会遇到各种软件版本冲突问题。

Docker就可以很好地解决这些问题，它其实可以理解为就是一个非常轻量化的虚拟机，我们可以在宿主服务器上新建很多个这种被称为容器的虚拟机，然后在里面配置我们的开发环境，且这些配置好的环境是可以打包成镜像的，方便随时做分享和重用；不需要的时候，我们直接删除容器就好了，其资源是和我们的服务器宿主机完全隔离的。

Docker的具体使用可以自己搜索一下很多教程，这里主要介绍如何把GPU暴露给Docker的容器（因为大家都知道像是VMware这种虚拟机里面都是无法共享宿主机的GPU的），是通过nvidia-docker实现的。

以前为了配置nvidia-docker，需要安装完docker之后再安装单独的nvidia docker2，而现在只需要安装nvidia container toolkit即可，更加方便了。
docker安装在官网上有详细的介绍或者运行下面的命令安装：

1
2
3
4
sudo apt-get update
sudo apt-get install docker.io
systemctl start docker
systemctl enable docker

可以运行这条命令检查是否安装成功：

1
docker version

安装NVIDIA Container Toolkit

1
2
3
4
5
6
7
8
9
##首先要确保已经安装了nvidia driver
#添加源
distribution=$(. /etc/os-release;echo $ID$VERSION_ID)
curl -s -L https://nvidia.github.io/nvidia-docker/gpgkey | sudo apt-key add -
curl -s -L https://nvidia.github.io/nvidia-docker/$distribution/nvidia-docker.list | sudo tee /etc/apt/sources.list.d/nvidia-docker.list

安装并重启
sudo apt-get update && sudo apt-get install -y nvidia-container-toolkit
sudo systemctl restart docker

安装完成后可以新建一个容器测试一下：

1
sudo docker run -it --name test_nvidia_docker --gpus all nvidia/cuda:11.1-base

其中最后的参数nvidia/cuda:11.1-base 是Nvidia官方的镜像，需要根据工作站主机中实际安装的cuda版本进行修改，版本可以用nvcc -V查看。
进入容器之后可以跑一下nvidia-smi命令看看

环境测试

这里通过一个简单的python脚本测试一下GPU训练是否一切正常，跑一个DL里面的Hello World程序，通过两种方法测试：本地conda和docker虚拟机。以后的开发过程中一般还是使用Docker的方式来进行更为优雅。
本地Conda环境方式：
先用conda新建一个python3.8+pytorch1.7+cuda11.0的虚拟环境：

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

创建完成后进入环境：

1
conda activate python_38-pytorch_1.7.0

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

1
which pip

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

安装pytorch，可以参考官网的安装命令

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
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),
	                       1.   * batch_idx / len(train_loader), loss.item()))
	
	
def main():
	cudnn.benchmark = True
	torch.manual_seed(1)
	device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
	print("Using device: {}".format(device))
	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()

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

Docker环境方式：
首先还是新建一个Docker镜像，运行下面的命令：

1
2
3
4
5
sudo docker run  -it  --name train_mnist \
-v /etc/timezone:/etc/timezone \
-v /etc/localtime:/etc/localtime \
-v /home/user/WorkSpace/_share:/home/workspace/_share  \
--gpus all nvidia/cuda:11.1-base

就进入到了带gpu的ubuntu20.04容器中，效果可以参考文章开头的视频。按照前面的配置方法同样配置好pytorch和其他软件包，然后运行同样的脚本，也可以得到上述输出，说明gpu在docker中正常工作。

clash的配置

Clash 项目地址：https://github.com/Dreamacro/clash；
下载 clash-linux.gz
直接双击下好的包解压缩，提取 clash-linux 至你想存放的文件夹下；
右键点击 clash-linux，选择属性，权限处勾选允许以程序执行：
然后双击 clash-linux，点击运行，此时 clash 已经在后台运行了，并且生成/.config/clash文件夹；
编辑/.config/clash下的 config.yml文件，即自己的服务器及规则等信息；
重新启动 clash-linux 以加载配置文件，可通过 http://clash.razord.top 进行策略组节点的切换，连接的 ip 和端口根据自己的 config.yml 中的external-controller填写；
使用系统代理（推荐），系统代理可在控制中心->网络->系统代理->手动处填写（根据自己配置文件里的端口填写） 配置系统proxy，以ubuntu为例，在Settings -> Network -> Network proxy ，选择手动配置，按config.yaml内容设置相应IP地址和端口值，如果 clash运行在本机那地址写127.0.0.1就行了。

操作顺序的问题需要注意一下，先运行clash，再打开浏览器进入clash.razord.top，按实际测速结果选择合适的代理服务器，然后打开系统proxy。

这样做的原因是，如果先打开系统proxy，万一clash默认使用的那个proxy不能工作，那么不但无法正常代理上网，也无法进入clash.razord.top进行proxy选择。

20.04找个简单办法，搜索应用：启动应用程序，打开添加，然后只需要找到你clash放置的位置，保存即可，再次开机就直接clash在后台了，同样可以平时ps -x
找到进程kill掉。

工作站维护篇

  • 备份
    由于Linux本身万物皆文件的设计理念，加上root用户对几乎全部的系统文件都有访问和更改的权限，因此Linux系统的备份和还原其实非常简单，我们直接打包整个根文件系统就可以了。

我们可以使用tar命令来打包并压缩文件系统，不过这里在打包的过程中需要排除一些不需要文件，或者与新系统文件冲突的文件，包括/tmp、/proc、/lost+found 等目录。

找一个你想保存备份文件的目录，运行下面的命令：

1
tar -cvpzf ubuntu_backup@`date +%Y-%m+%d`.tar.gz --exclude=/proc --exclude=/tmp --exclude=/boot  --exclude=/lost+found --exclude=/media --exclude=/mnt --exclude=/run /

我们会得到一个名为backup.tgz的压缩文件，这个文件包含我们需要备份的系统的全部内容。

  • 还原

如果系统没有出问题可以正常启动的话，那直接在刚刚的压缩包找找到想还原的文件替换就好了。而如果系统无法启动了，或者说想换一块硬盘克隆一样的系统，那么可以按一下步骤操作：

  1. 重装干净的Ubuntu系统。
    跟上面介绍的一样，使用U盘给目标磁盘重装一个干净的系统，这一步是为了省去自己分配存储空间和挂载的麻烦，如果你会自己配置的话那也可以不做这一步。
    再次使用U盘进入系统，这次选择try ubuntu without installing，然后可以看到挂载好的刚刚安装了干净系统的另一个盘，我们在这里对盘里的根文件系统进行一些文件的提取：
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    sudo su

    # 在tryUbuntu根目录下有media文件夹，里面是U盘文件夹和新安装的系统文件夹，在在里分别用（U盘）和（UBUNTU）表示
    cd /media/（U盘）
    mount -o remount rw ./
     ​
    # 将新系统根目录下/boot/grub/grub.cfg文件备份到U盘中
    sudo cp /media/(Ubuntu)/boot/grub/grub.cfg ./    
     ​
    # 将新系统根目录下/etc/fstab文件备份到U盘中，fstab是与系统开机挂载有关的文件，grub.cfg是与开机引导有关的文件，所以这一步至关重要
    sudo cp /media/(UBUNTU)/etc/fstab ./
     ​
    # 这一步删除新装ubuntu全部的系统文件，有用的fstab及grub.cfg已经备份
    cd /media/(UBUNTU)
    sudo rm -rf ./*
     ​
    # 将U盘中backup.tgz复制到该目录下并解压缩
    cp /media/(U盘)/backup.tgz ./
    sudo tar xvpfz backup.tgz ./
     ​
    # 创建打包系统时排除的文件
    sudo mkdir proc lost+found mnt sys media
    这一步完成后，在用我们在新系统中备份的fatab及grub.cfg 文件去替换压缩包中解压出来的同名文件，sudo reboot重启后就发现系统已经恢复到备份时的状态，包括各种框架，环境，系统设置。