如何使用keras，python和深度学习进行多GPU训练

AI算法与图像处理

发布于 2019-08-23 15:16:52

3.3K0

发布于 2019-08-23 15:16:52

作者：pyimagesearch 原文链接：https://www.pyimagesearch.com/2017/10/30/how-to-multi-gpu-training-with-keras-python-and-deep-learning/ 编译：AI算法与图像处理

内容简介

Keras简单而优雅，类似于scikit-learn。然而，它非常强大，能够实施和训练最先进的深度神经网络。

然而，我们对keras最感到受挫的一个原因，是在多GPU环境下使用，因为这是非常重要的。

如果你使用Theano，请忽略它——多GPU训练，这并不会发生。

TensorFlow还是有使用的可能性，但它可能需要大量的样板代码和调整才能是你的网络使用多个GPU进行训练。

在使用多GPU训练的时，我更喜欢用mxnet后端（或甚至直接是mxnet库）而不是keras，但这会引入更多配置进行处理。

随着François Chollet’s宣布tensorflow后端对多GPU的支持已经融入到keras v2.0.9时，所有这一切都发生了改变。大部分功劳归功于 kuza55(ID)和他们的keras-extras回购。

我已经使用并测试了这个多GPU功能近一年，我非常高兴能将它视为官方keras发行版的一部分。

在今天文章的其他部分中，我将演示如何使用keras，python和深度学习训练图像分类的CNN。

MiniGoogLeNet 深度学习框架

图1：MiniGoogLeNet架构是它的大兄弟GoogLeNet / Inception的一个小版本。

在上面的图1中，我们可以看到单个卷积（左），初始（中）和下采样（右）模块，然后是从这些模块来构建MiniGoogLeNet架构（底部）。我们将在本文后面的多GPU实验中使用MiniGoogLeNet架构。

在MiniGoogLeNet中的Inception是由Szegedy 等人设计的，是原始Inception模块的变体。

我首先从@ericjang11 和 @pluskid 的推文中了解了这个“Miniception”模块，它们精美地可视化模块和相关的MiniGoogLeNet架构。

在做了一些研究后，我发现这张图片来自张等人2017的文章https://arxiv.org/abs/1611.03530

然后我开始在keras和python中应用MiniGoogLe架构——甚至使用python进行计算机视觉深度学习这本书的一部分。

对MiniGoogLeNet实现全面的复习超出了本文的范围，因此如果你对网络的工作原理（以及如何编码）感兴趣，可以参阅这本书https://www.pyimagesearch.com/deep-learning-computer-vision-python-book/

使用keras和多GPU训练一个深层神经网络

首先确保在环境中安装和更新keras 2.09（或更高版本）：

pip3 install --upgrade keras

这里，新建一个文件并命名为train.py，然后插入下面的代码：

# 设置matplotlib后端，这样子数字可以保存在后端（如果你使用的是headless server，请取消注释下面的行）
# import matplotlib
# matplotlib.use("Agg")
 
# 导入必要的包
from pyimagesearch.minigooglenet import MiniGoogLeNet
from sklearn.preprocessing import LabelBinarizer
from keras.preprocessing.image import ImageDataGenerator
from keras.callbacks import LearningRateScheduler
from keras.utils.training_utils import multi_gpu_model
from keras.optimizers import SGD
from keras.datasets import cifar10
import matplotlib.pyplot as plt
import tensorflow as tf
import numpy as np
import argparse

如果你使用的是headless server，则需要通过取消注释行来配置2-3行的matplotlib后端。这样可以将matplotlib图保存到磁盘。如果你没有使用headless server（即，你的键盘+鼠标+显示器插入系统，则可以将线条注释掉）。

这里，我们导入这个脚本所需的包。

第6行从我的pyimagesearch模块导入MiniGoogLeNet。

另一个值得注意的是12行的导入了CIFAR10数据集。这个辅助函数将使我们导入CIFAR-10数据集。

现在让我们解析命令行参数：

# 构建解析参数
ap = argparse.ArgumentParser()
ap.add_argument("-o", "--output", required=True,
  help="path to output plot")
ap.add_argument("-g", "--gpus", type=int, default=1,
  help="# of GPUs to use for training")
args = vars(ap.parse_args())
 
# 获取GPU的数量并将其存储在一个传输变量中
G = args["gpus"]

我们使用argparse去解析一个必要参数和一个可选参数：

--output：训练完成后的输出图的路径
--gpus：用于训练的gpu数量

加载命令行参数后，为了方便起见，我们将GPU的数量存储为G（10行）。

这里，我们初始化用于配置我们的训练过程的两个重要遍历，然后定义poly_decay，一个等同于caff的多项式学习速率衰减的学习率调度函数https://stackoverflow.com/questions/30033096/what-is-lr-policy-in-caffe：

# 定义要训练的周期数以及初始学习率
NUM_EPOCHS = 70
INIT_LR = 5e-3
 
def poly_decay(epoch):
  # 初始化最大周期数，基本学习率和多项式的幂次
  maxEpochs = NUM_EPOCHS
  baseLR = INIT_LR
  power = 1.0
 
  # 根据多项式衰减计算新的学习率
  alpha = baseLR * (1 - (epoch / float(maxEpochs))) ** power
 
  # 返回新的学习率
  return alpha

我们设置 NUM_EPOCHS=70——这是我们训练数据将要传递给网络的次数（周期）

初始化学习率INIT_LR=5e-3，这是在之前的试验中发现的值

这里定义poly_decay函数，它相当于Caffe的多项式学习速率衰减。本质上，此功能可在训练期间更新学习率，并在每个时期后有效减少学习率。设置power=1.0会将衰减从多项式变为线性。

接下来我们将加载我们的训练+测试数据并将图像数据从整数转换为浮点数：

# 加载训练和测试数据，将图像从整数转换为浮点数
print("[INFO] loading CIFAR-10 data...")
((trainX, trainY), (testX, testY)) = cifar10.load_data()
trainX = trainX.astype("float")
testX = testX.astype("float")

这里，将对数据应用平均值相减：

mean = np.mean(trainX, axis=0)
trainX -= mean
testX -= mean

计算所有训练图像的平均值，然后从训练和测试集中的每个图像中减去平均值。

然后执行独热编码（one-hot encoding）：

# 构造用于数据增强的图像生成器并构造一系列的回调函数
aug = ImageDataGenerator(width_shift_range=0.1,
  height_shift_range=0.1, horizontal_flip=True,
  fill_mode="nearest")
callbacks = [LearningRateScheduler(poly_decay)]

第2行构造用于数据增强的图像生成器。

由于这些改变，网络不断地看到增强的示例 - 这使得网络能够更好地概括验证数据，同时可能在训练集上表现更差。在大多数情况下，这些权衡是值得的。

我们在第5行创建了一个回调函数，它允许我们的学习速率在每个周期后衰减 - 注意我们的函数名称poly_decay。

我们接下来检查GPU变量：

# 检测我们是否只使用一个GPU进行编译
if G <= 1:
  print("[INFO] training with 1 GPU...")
  model = MiniGoogLeNet.build(width=32, height=32, depth=3,
    classes=10)

如果GPU计数小于或等于1，我们通过.build函数初始化模型（第2-5行），否则我们将在训练期间并行化模型：

# 否则，我们正在使用多个GPU进行编译
else:
  print("[INFO] training with {} GPUs...".format(G))
 
  # 我们将在* every * GPU上存储模型的副本，然后将CPU上的渐变更新结果组合在一起
  with tf.device("/cpu:0"):
    # 初始化模型
    model = MiniGoogLeNet.build(width=32, height=32, depth=3,
      classes=10)
  
  # 是模型并行
  model = multi_gpu_model(model, gpus=G)

Keras中创建一个多GPU模型需要一些额外的代码，但不多！

首先，您将在第6行注意到我们已指定使用CPU（而不是GPU）作为网络上下文。

为什么我们需要CPU？

CPU负责处理任何开销（例如在GPU内存上移动和移动训练图像），而GPU本身则负担繁重。

在这种情况下，CPU实例化基本模型。

然后我们可以在第12行调用multi_gpu_model。这个函数将模型从CPU复制到我们所有的GPU，从而获得一个机，多个GPU数据并行性。

在训练我们的网络时，图像将被批量分配到每个GPU。CPU将从每个GPU获得梯度，然后执行梯度更新步骤。

然后我们可以编译我们的模型并启动训练过程：

# 初始化优化器和模型
print("[INFO] compiling model...")
opt = SGD(lr=INIT_LR, momentum=0.9)
model.compile(loss="categorical_crossentropy", optimizer=opt,
  metrics=["accuracy"])
 
# 训练网络
print("[INFO] training network...")
H = model.fit_generator(
  aug.flow(trainX, trainY, batch_size=64 * G),
  validation_data=(testX, testY),
  steps_per_epoch=len(trainX) // (64 * G),
  epochs=NUM_EPOCHS,
  callbacks=callbacks, verbose=2)

第3行构建了一个随机梯度下降（SGD）优化器。

随后，我们使用SGD优化器和分类的交叉熵损失函数编译模型。

现在准备训练网络了！

为了启动训练过程，我们调用model.fit_generator函数并提供必要的参数。

我们制定每个GPU上的batch大小64，因此batch_size=64*G

我们训练将持续70个周期（前面已经制定）。

梯度更新的结果将在CPU上组合，然后在整个训练过程中应用与每个GPU。

既然训练和测试已经完成，让我们画出损失/准确率图，以便可视化整个训练过程。

# 获取历史对象字典
H = H.history
 
# 绘制训练的loss和准确率的图
N = np.arange(0, len(H["loss"]))
plt.style.use("ggplot")
plt.figure()
plt.plot(N, H["loss"], label="train_loss")
plt.plot(N, H["val_loss"], label="test_loss")
plt.plot(N, H["acc"], label="train_acc")
plt.plot(N, H["val_acc"], label="test_acc")
plt.title("MiniGoogLeNet on CIFAR-10")
plt.xlabel("Epoch #")
plt.ylabel("Loss/Accuracy")
plt.legend()
 
# 保存图
plt.savefig(args["output"])
plt.close()

最后一块仅使用matplotlib绘制训练/测试的loss和准确率的曲线图（6-15行），然后将曲线图保存到磁盘中（18行）。

keras多GPU训练结果

让我们检查一下辛勤的劳动成果。

首先，使用附带链接中的代码。然后，可以按照结果进行操作。

利用单个GPU进行训练以获取基准线（baseline）：

$ python3 train.py --output single_gpu.png
[INFO] loading CIFAR-10 data...
[INFO] training with 1 GPU...
[INFO] compiling model...
[INFO] training network...
Epoch 1/70
 - 64s - loss: 1.4323 - acc: 0.4787 - val_loss: 1.1319 - val_acc: 0.5983
Epoch 2/70
 - 63s - loss: 1.0279 - acc: 0.6361 - val_loss: 0.9844 - val_acc: 0.6472
Epoch 3/70
 - 63s - loss: 0.8554 - acc: 0.6997 - val_loss: 1.5473 - val_acc: 0.5592
...
Epoch 68/70
 - 63s - loss: 0.0343 - acc: 0.9898 - val_loss: 0.3637 - val_acc: 0.9069
Epoch 69/70
 - 63s - loss: 0.0348 - acc: 0.9898 - val_loss: 0.3593 - val_acc: 0.9080
Epoch 70/70
 - 63s - loss: 0.0340 - acc: 0.9900 - val_loss: 0.3583 - val_acc: 0.9065
Using TensorFlow backend.
 
real    74m10.603s
user    131m24.035s
sys     11m52.143s

图2 在单个GPU上使用Keras在CIFAR-10上训练和测试MiniGoogLeNet网络架构的实验结果

对于这个实验，我在我的NVIDIA DevBox上使用单个Titan X GPU进行了训练。每个时期花费约63秒，总训练时间为74分10秒。

然后我执行以下命令来训练我的所有四个Titan X GPU：

$ python3 train.py --output multi_gpu.png --gpus 4
[INFO] loading CIFAR-10 data...
[INFO] training with 4 GPUs...
[INFO] compiling model...
[INFO] training network...
Epoch 1/70
 - 21s - loss: 1.6793 - acc: 0.3793 - val_loss: 1.3692 - val_acc: 0.5026
Epoch 2/70
 - 16s - loss: 1.2814 - acc: 0.5356 - val_loss: 1.1252 - val_acc: 0.5998
Epoch 3/70
 - 16s - loss: 1.1109 - acc: 0.6019 - val_loss: 1.0074 - val_acc: 0.6465
...
Epoch 68/70
 - 16s - loss: 0.1615 - acc: 0.9469 - val_loss: 0.3654 - val_acc: 0.8852
Epoch 69/70
 - 16s - loss: 0.1605 - acc: 0.9466 - val_loss: 0.3604 - val_acc: 0.8863
Epoch 70/70
 - 16s - loss: 0.1569 - acc: 0.9487 - val_loss: 0.3603 - val_acc: 0.8877
Using TensorFlow backend.
 
real    19m3.318s
user    104m3.270s
sys     7m48.890s