前言

什么是GPU？
GPU（Graphic Process Units，图形处理器）。是一种单芯片处理器，主要用于管理和提高视频和图形的性能。GPU 加速计算是指同时利用图形处理器 (GPU) 和 CPU，加快应用程序的运行速度。
为什么要用GPU？
深度学习涉及很多向量或多矩阵运算，如矩阵相乘、矩阵相加、矩阵-向量乘法等。深层模型的算法，如BP，Auto-Encoder，CNN等，都可以写成矩阵运算的形式，无须写成循环运算。然而，在单核CPU上执行时，矩阵运算会被展开成循环的形式，本质上还是串行执行。GPU的众核体系结构包含几千个流处理器，可将矩阵运算并行化执行，大幅缩短计算时间。
如何使用GPU？
现在很多深度学习工具都支持GPU运算，使用时只要简单配置即可。Pytorch支持GPU，可以通过to(device)函数来将数据从内存中转移到GPU显存，如果有多个GPU还可以定位到哪个或哪些GPU。Pytorch一般把GPU作用于张量(Tensor)或模型（包括torch.nn下面的一些网络模型以及自己创建的模型）等数据结构上。

一、关于CUDA的函数接口

1.1 torch.cuda

如何查看平台GPU的配置信息？在cmd命令行输入命令nvidia-smi即可 (适合于Linux或Windows环境)。

第一次使用这个命令可能会显示
‘nvidia-smi’ 不是内部或外部命令，也不是可运行的程序或批处理文件。
我们只需要配置一下环境变量即可，配置环境的路径在下面，

C:\Program Files\NVIDIA Corporation\NVSMI

然后添加环境变量后，即可显示本机的GPU配置信息。示例如下：

import torchprint(torch.cuda.is_available()) # 查看系统GPU是否可以使用，经常用来判断是否装好gpu版的pytorch
print(torch.cuda.current_device())# 返回当前设备序号
print(torch.cuda.get_device_name(0))# 返回第0号设备的name
print(torch.cuda.device_count())# 返回可使用的gpu的数量
print(torch.cuda.memory_allocated(device="cuda:0"))#返回0号设备的当前GPU显存使用量(以字节为单位）

1.2 torch.device

作为Tensor 的一种属性，其包含了两种设备类型，cpu和gpu，通常通过两种方式来进行创建：

#1.通过字符串创建
eg: 
torch.device('cuda:0')
torch.device('cpu')
torch.device('cuda')  # 当前cuda设备#2.通过字符串加设备编号创建
eg:
torch.device('cuda', 0)
torch.device('cpu', 0)#常见的几种创建gpu设备上的Tensor对象:
torch.randn((2,3),device = torch.device('cuda:0'))
torch.randn((2,3),device = 'cuda:0')
torch.randn((2,3),device = 0)  #历史遗留做法，仅支持gpu

# 把数据从内存转移到GPU，一般针对张量（我们需要的数据）和模型。 对张量（类型为FloatTensor或者是LongTensor等），一律直接使用方法.to(device)或.cuda()即可。
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
#或device = torch.device("cuda:0")
device1 = torch.device("cuda:1")  
for batch_idx, (img, label) in enumerate(train_loader):img=img.to(device)label=label.to(device)
# 对于模型来说，也是同样的方式，使用.to(device)或.cuda来将网络放到GPU显存。
#实例化网络
model = Net()
model.to(device)   #使用序号为0的GPU
#或model.to(device1) #使用序号为1的GPU

1.3 .to()

进行设备转化，也是常用的设置gpu的方式。
我个人比较喜欢用的一种方式就是：
device=torch.device(“cuda” if torch.cuda.is_available() else “cpu”)

通常可以这样调用:to(device=None, dtype=None, non_blocking=False)
#第一个可以设置当前的设备，比如device=torch.device('cuda:0')
#或者device=torch.device("cuda" if torch.cuda.is_available() else "cpu")
#第二个就是数据类型了，如torch.float,torch.int,torch.double
#第三个参数，若设置为True, 并且此对象的资源存储在固定内存上(pinned memory)，那么此cuda()函数产生的复制将与host端的原storage对象保持同步。否则此参数不起作用

1.4 使用指定的GPU

PyTorch默认使用从0开始的GPU,常有以下两种方式来指定特定的GPU

1.CUDA_VISIBLE_DEVICES
终端设置:  CUDA_VISIBLE_DEVICES=1,2  python train.py    (举个例子)
代码里设置:import osos.environ["CUDA_VISIBLE_DEVICES"] = '1,2'
2.torch.cuda.set_device()
代码里设置:import torchtorch.cuda.set_device(id)不过官方建议使用CUDA_VISIBLE_DEVICES，不建议使用 set_device 函数。

1.5 多GPU训练

为了提高训练速度，常常一个机器有多张gpu，这时候便可以进行并行训练，提高效率。而并行训练又可分为数据并行处理和模型并行处理。
数据并行处理指的是使用同一个模型，将数据均匀分到多种gpu上，进行训练；
模型并行处理指的是多张gpu训练模型的不同部分，使用同一批数据。

二、训练实例代码展示

2.1 数据并行处理

本代码以波士顿房价数据为例，共506个样本，13个特征。数据划分成训练集和测试集，然后用data.DataLoader转换为可批加载的方式。采用nn.DataParallel并发机制，环境有2个GPU。当然，数据量很小，按理不宜用nn.DataParallel，这里只是为了说明使用方法。

from sklearn import datasets
from sklearn.model_selection import train_test_split
import torch
import torch.nn as nn
import torch.nn.functional as F# 加载数据
boston = datasets.load_boston()
X, y = (boston.data, boston.target)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
# 组合训练数据及标签
myset = list(zip(X_train, y_train))# 把数据转换为批处理加载方式批次大小为128,打乱数据
from torch.utils import data
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
dtype = torch.FloatTensor
train_loader = data.DataLoader(myset,batch_size=128,shuffle=True)# 定义网络
class Net1(nn.Module):"""使用sequential构建网络，Sequential()函数的功能是将网络的层组合到一起"""def __init__(self, in_dim, n_hidden_1, n_hidden_2, out_dim):super(Net1, self).__init__()self.layer1 = torch.nn.Sequential(nn.Linear(in_dim, n_hidden_1))self.layer2 = torch.nn.Sequential(nn.Linear(n_hidden_1, n_hidden_2))self.layer3 = torch.nn.Sequential(nn.Linear(n_hidden_2, out_dim))def forward(self, x):x1 = F.relu(self.layer1(x))x1 = F.relu(self.layer2(x1))x2 = self.layer3(x1)# 显示每个GPU分配的数据大小print("\tIn Model: input size", x.size(), "output size", x2.size())return x2if __name__ == '__main__':# 把模型转换为多GPU并发处理格式device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")# 实例化网络model = Net1(13, 16, 32, 1)if torch.cuda.device_count() > 1:print("Let's use", torch.cuda.device_count(), "GPUs")# dim = 0 [64, xxx] -> [32, ...], [32, ...] on 2GPUsmodel = nn.DataParallel(model)model.to(device)# 选择优化器及损失函数optimizer_orig = torch.optim.Adam(model.parameters(), lr=0.01)loss_func = torch.nn.MSELoss()# 模型训练，并可视化损失值# from torch.utils.tensorboard import SummaryWriter# writer = SummaryWriter(log_dir='logs')for epoch in range(100):model.train()for data, label in train_loader:input = data.type(dtype).to(device)label = label.type(dtype).to(device)output = model(input)loss = loss_func(output, label)# 反向传播optimizer_orig.zero_grad()loss.backward()optimizer_orig.step()print("Outside: input size", input.size(), "output_size", output.size())# writer.add_scalar('train_loss_paral', loss, epoch)

运行结果：

Let's use 2 GPUs
DataParallel(
(module): Net1(
(layer1): Sequential(
(0): Linear(in_features=13, out_features=16, bias=True)
)
(layer2): Sequential(
(0): Linear(in_features=16, out_features=32, bias=True)
)
(layer3): Sequential(
(0): Linear(in_features=32, out_features=1, bias=True)
)
)
)

从运行结果可以看出，一个批次数据（batch-size=128）拆分成两份，每份大小为64，分别放在不同的GPU上。

In Model: input size torch.Size([64, 13]) output size torch.Size([64, 1])
In Model: input size torch.Size([64, 13]) output size torch.Size([64, 1])
Outside: input size torch.Size([128, 13]) output_size torch.Size([128, 1])
In Model: input size torch.Size([64, 13]) output size torch.Size([64, 1])
In Model: input size torch.Size([64, 13]) output size torch.Size([64, 1])
Outside: input size torch.Size([128, 13]) output_size torch.Size([128, 1])

损失情况：

图形中出现较大振幅，是由于采用批次处理，而且数据没有做任何预处理，对数据进行规范化应该更平滑一些，大家可以尝试一下。
单机多GPU也可使用DistributedParallel，它多用于分布式训练，但也可以用在单机多GPU的训练，配置比使用nn.DataParallel稍微麻烦一点，但是训练速度和效果更好一点。具体配置为：

#初始化使用nccl后端
torch.distributed.init_process_group(backend="nccl")
#模型并行化
model=torch.nn.parallel.DistributedDataParallel(model)

单机运行时使用下面方法启动

python -m torch.distributed.launch main.py

2.2 模型并行处理

这种方法，自然对应的是模型太大的情况。当模型较大时，将模型的不同层放于不同的gpu上，进行并行的处理。
只需更改几行，就可以在多个GPU上运行现有的单GPU模块。以下代码显示了如何分解 torchvision.models.reset50() 为两个GPU。思想是从现有 ResNet模块继承，并在构建过程中将层拆分为两个GPU。然后，覆盖 forward方法来缝合两个子网，通过相应地移动中间输出。

from torchvision.models.resnet import ResNet, Bottlenecknum_classes = 1000class ModelParallelResNet50(ResNet):def __init__(self, *args, **kwargs):super(ModelParallelResNet50, self).__init__(Bottleneck, [3, 4, 6, 3], num_classes=num_classes, *args, **kwargs)self.seq1 = nn.Sequential(self.conv1,self.bn1,self.relu,self.maxpool,self.layer1,self.layer2).to('cuda:0')  # 放置在第1个GPU上self.seq2 = nn.Sequential(self.layer3,self.layer4,self.avgpool,).to('cuda:1')  # 放置在第2个GPU上self.fc.to('cuda:1')def forward(self, x):x = self.seq2(self.seq1(x).to('cuda:1'))return self.fc(x.view(x.size(0), -1))# 其中，backward()和torch.optim将自动处理梯度，只需确保调用损失函数时标签与输出在同一设备上。

对于模型太大而无法放入单个GPU的情况，上述实现解决了该问题。但是，你可能已经注意到，如果模型合适，它（model parallel）将比在单个GPU上运行要慢。这是因为在任何时间点，两个GPU中只有一个在工作，而另一个在那儿什么也没做。在 layer2 和 layer3之间，中间输出需要从 cuda:0 复制到 cuda:1，这使得性能进一步恶化。

2.2.1 通过流水线输入（Pipelining Inputs）加速

结果表明，模型并行实现的执行时间 比现有的单GPU实现更长。因此，我们可以得出结论，在GPU之间来回复制张量大约有7％的开销。有待改进的地方，因为我们知道在整个执行过程中，两个GPU中的一个会处于空闲状态。一种选择是将每个批次进一步划分为拆分流水线，以便当一个拆分到达第二子网时，可以将下一个拆分馈入第一子网。这样，两个连续的拆分可以在两个GPU上同时运行。
在以下实验中，我们将每批次 120-image 进一步划分为 20-image 。当PyTorch异步启动CUDA操作时，该实现无需生成多个线程即可实现并发。

class PipelineParallelResNet50(ModelParallelResNet50):def __init__(self, split_size=20, *args, **kwargs):super(PipelineParallelResNet50, self).__init__(*args, **kwargs)self.split_size = split_sizedef forward(self, x):splits = iter(x.split(self.split_size, dim=0))s_next = next(splits)s_prev = self.seq1(s_next).to('cuda:1')ret = []for s_next in splits:# A. s_prev runs on cuda:1s_prev = self.seq2(s_prev)ret.append(self.fc(s_prev.view(s_prev.size(0), -1)))# B. s_next runs on cuda:0, which can run concurrently with As_prev = self.seq1(s_next).to('cuda:1')s_prev = self.seq2(s_prev)ret.append(self.fc(s_prev.view(s_prev.size(0), -1)))return torch.cat(ret)setup = "model = PipelineParallelResNet50()"
pp_run_times = timeit.repeat(stmt, setup, number=1, repeat=num_repeat, globals=globals())
pp_mean, pp_std = np.mean(pp_run_times), np.std(pp_run_times)plot([mp_mean, rn_mean, pp_mean],[mp_std, rn_std, pp_std],['Model Parallel', 'Single GPU', 'Pipelining Model Parallel'],'mp_vs_rn_vs_pp.png')

不同的split 会有不同的效果，没有通用的多流解决方案适用于所有模型。

三、使用GPU注意事项

使用GPU可以提升我们训练的速度，如果使用不当，可能影响使用效率，具体使用时要注意以下几点：

① GPU的数量尽量为偶数，奇数的GPU有可能会出现异常中断的情况；
② GPU很快，但数据量较小时，效果可能没有单GPU好，甚至还不如CPU；
③ 如果内存不够大，使用多GPU训练的时候可通过设置pin_memory为False，当然使用精度稍微低一点的数据类型有时也效果。

参考资料：
1、模型并行最佳实践（PyTorch）
2、pytorch——关于GPU的一些知识