使用Keras进行多GPU训练 multi_gpu_model

使用Keras训练具有多个GPU的深度神经网络（照片来源：Nor-Tech.com）。

摘要

在今天的博客文章中，我们学习了如何使用多个GPU来训练基于Keras的深度神经网络。

使用多个GPU使我们能够获得准线性加速。

为了验证这一点，我们在CIFAR-10数据集上训练了MiniGoogLeNet。

使用单个GPU，我们能够获得63秒的时间段，总训练时间为74分10秒。

然而，通过使用Keras和Python的多GPU训练，我们将训练时间减少到16秒，总训练时间为19m3s。

使用Keras启用多GPU培训就像单个函数调用一样简单 - 我建议您尽可能使用多GPU培训。在未来，我想象 multi_gpu_model 将演变，让我们进一步定制专门其中的GPU应该用于训练，最终实现多系统的训练也是如此。

方法：使用Keras，Python和深度学习进行多GPU培训

当我第一次开始使用Keras时，我爱上了API。它简单而优雅，类似于scikit-learn。然而它非常强大，能够实施和训练最先进的深度神经网络。

然而，我对Keras的最大挫折之一是在多GPU环境中使用它可能有点不重要。

如果您使用Theano，请忘掉它 - 多GPU培训不会发生。
TensorFlow是一种可能性，但它可能需要大量的样板代码和调整才能使您的网络使用多个GPU进行训练。

我更喜欢在执行多GPU培训时使用mxnet后端（甚至是mxnet库直接）到Keras，但这引入了更多的配置来处理。

所有这一切都与改变弗朗索瓦CHOLLET宣布，使用TensorFlow后端多GPU的支持，现在在烤到Keras V2.0.9。大部分功劳归功于@ kuza55和他们的keras-extras回购。

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

在今天博客文章的剩余部分中，我将演示如何使用Keras，Python和深度学习训练卷积神经网络进行图像分类。

MiniGoogLeNet深度学习架构

图1： MiniGoogLeNet架构是它的大兄弟GoogLeNet / Inception的一个小版本。图片来自@ ericjang11和@pluskid。

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

MiniGoogLenet中的Inception模块是Szegedy等人设计的原始Inception模块的变体。

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

在做了一些研究后，我发现这张图片来自张等人的2017年出版物“ 理解深度学习需要重新思考泛化”。

然后我开始在Keras + Python中实现MiniGoogLeNet架构 - 我甚至将它作为使用Python进行计算机视觉深度学习的一部分。

对MiniGoogLeNet Keras实现的全面审查超出了本博文的范围，因此如果您对网络的工作原理（以及如何编码）感兴趣，请参阅我的书。

否则，您可以使用此博客文章底部的“下载”部分下载源代码。

使用Keras和多个GPU训练深度神经网络

让我们继续使用Keras和多个GPU开始培训深度学习网络。

首先，您需要确保在虚拟环境中安装和更新Keras 2.0.9（或更高版本）（我们在本书中使用名为dl4cv的虚拟环境）：

1 2	$ workon dl4cv $ pip install -- upgrade keras

从那里，打开一个新文件，将其命名为 train .py ，并插入以下代码：

# set the matplotlib backend so figures can be saved in the background

# (uncomment the lines below if you are using a headless server)

# import matplotlib

# matplotlib.use("Agg")

# import the necessary packages

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

如果您使用的是无头服务器，则需要通过取消注释行来配置第3行和第4行的matplotlib后端。这样可以将matplotlib图保存到磁盘。如果您没有使用无头服务器（即，您的键盘+鼠标+显示器已插入系统，则可以将线条注释掉）。

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

第7行从我的pyimagesearch 模块导入MiniGoogLeNet （包含在“下载”部分中提供的下载）。

另一个值得注意的导入是在 第13行，我们导入CIFAR10数据集。这个辅助函数将使我们能够只用一行代码从磁盘加载CIFAR-10数据集。

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

# construct the argument parse and parse the arguments

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 ( ) )

# grab the number of GPUs and store it in a conveience variable

G = args [ "gpus" ]

我们使用 argparse 解析一个需要和一个可选的参数线20-25：

- 输出：训练完成后输出图的路径。
- gpus ：用于培训的GPU数量。

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

从那里，我们初始化用于配置我们的训练过程的两个重要变量，然后定义 poly_decay ，一个等同于Caffe的多项式学习速率衰减的学习速率调度函数：

# definine the total number of epochs to train for along with the

# initial learning rate

NUM_EPOCHS = 70

INIT_LR = 5e - 3

def poly_decay ( epoch ) :

# initialize the maximum number of epochs, base learning rate,

# and power of the polynomial

maxEpochs = NUM_EPOCHS

baseLR = INIT_LR

power = 1.0

# compute the new learning rate based on polynomial decay

alpha = baseLR * ( 1 - ( epoch / float ( maxEpochs ) ) ) * * power

# return the new learning rate

return alpha

我们设置 NUM _ EPOCHS = 70 - 这是我们的训练数据将通过网络的次数（时期）（第32行）。

我们还初始化学习率 INIT_LR = 5e - 3 ，这是在之前的试验（第33行）中通过实验发现的值。

从那里，我们定义 poly_decay 函数，它相当于Caffe的多项式学习速率衰减（第35-46行）。本质上，此功能可在训练期间更新学习速率，并在每个时期后有效地减少学习速度。设置功率= 1.0 会将衰减从多项式更改为线性。

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

# load the training and testing data, converting the images from

# integers to floats

print ( "[INFO] loading CIFAR-10 data..." )

( ( trainX , trainY ) , ( testX , testY ) ) = cifar10 . load_data ( )

trainX = trainX . astype ( "float" )

testX = testX . astype ( "float" )

从那里我们对数据应用平均减法：

# apply mean subtraction to the data

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

trainX -= mean

testX -= mean

在 第56行，我们计算所有训练图像的平均值，然后是 第57和58行，其中我们从训练和测试集中的每个图像中减去平均值。

然后，我们执行“one-hot encoding”，这是我在本书中更详细讨论的编码方案：

# convert the labels from integers to vectors

lb = LabelBinarizer ( )

trainY = lb . fit_transform ( trainY )

testY = lb . transform ( testY )

单热编码将分类标签从单个整数转换为向量，因此我们可以应用分类交叉熵损失函数。我们已经在第61-63行处理了这个问题。

接下来，我们创建一个数据增强器和一组回调：

# construct the image generator for data augmentation and construct

# the set of callbacks

aug = ImageDataGenerator ( width_shift_range = 0.1 ,

height_shift_range = 0.1 , horizontal_flip = True ,

fill_mode = "nearest" )

callbacks = [ LearningRateScheduler ( poly_decay ) ]

在67-69行，我们构建了用于数据增强的图像生成器。

数据增强覆盖在里面详细执业捆绑的深度学习计算机视觉与Python ; 然而，暂时理解这是一种在训练过程中使用的方法，我们通过对它们进行随机变换来随机改变训练图像。

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

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

我们接下来检查GPU变量：

# check to see if we are compiling using just a single GPU

if G <= 1 :

print ( "[INFO] training with 1 GPU..." )

model = MiniGoogLeNet . build ( width = 32 , height = 32 , depth = 3 ,

classes = 10 )

如果GPU计数小于或等于1，我们通过使用初始化模型。构建函数（第73-76行），否则我们将在训练期间并行化模型：

# otherwise, we are compiling using multiple GPUs

else :

print ( "[INFO] training with {} GPUs..." . format ( G ) )

# we'll store a copy of the model on *every* GPU and then combine

# the results from the gradient updates on the CPU

with tf . device ( "/cpu:0" ) :

# initialize the model

model = MiniGoogLeNet . build ( width = 32 , height = 32 , depth = 3 ,

classes = 10 )

# make the model parallel

model = multi_gpu_model ( model , gpus = G )

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

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

为什么我们需要CPU？

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

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

然后我们可以在第90行调用 multi_gpu_model。此功能将模型从CPU复制到我们所有的GPU，从而获得单机，多GPU数据并行性。

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

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

100

101

102

103

104

105

# initialize the optimizer and model

print ( "[INFO] compiling model..." )

opt = SGD ( lr = INIT_LR , momentum = 0.9 )

model . compile ( loss = "categorical_crossentropy" , optimizer = opt ,

metrics = [ "accuracy" ] )

# train the network

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 )

在 第94行，我们构建了一个随机梯度下降（SGD）优化器。

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

我们现在准备训练网络了！

为了启动培训过程，我们打电话给模型。fit_generator 并提供必要的参数。

我们希望每个GPU上的批量大小为64，因此由batch_size = 64 * G 指定。

我们的培训将持续70个时期（我们之前指定）。

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

现在培训和测试已经完成，让我们绘制损失/准确度，以便我们可以看到培训过程：

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

# grab the history object dictionary

H = H . history

# plot the training loss and accuracy

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 ( )

# save the figure

plt . savefig ( args [ "output" ] )

plt . close ( )

最后一个块仅使用matplotlib绘制训练/测试损失和准确度（第112-121行），然后将数字保存到磁盘（第124行）。

如果您想了解有关培训过程（以及内部工作原理）的更多信息，请参阅使用Python进行计算机视觉深度学习。

Keras多GPU结果

让我们检查一下我们辛勤工作的结果。

首先，使用本文底部的“下载”部分从本课程中获取代码。然后，您就可以按照结果进行操作

让我们在单个GPU上训练以获得基线：

$ python 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：

$ python 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

图3：在CIFAR10数据集上使用Keras和MiniGoogLeNet的多GPU培训结果（4个Titan X GPU）。训练结果类似于单GPU实验，而训练时间减少了约75％。

在这里你可以看到训练中的准线性加速：使用四个GPU，我能够将每个时期减少到只有 16秒。整个网络在19分3秒内完成了培训。

正如您所看到的，不仅可以轻松地训练具有Keras和多个GPU的深度神经网络，它也是 高效的！

注意：在这种情况下，单GPU实验获得的精度略高于多GPU实验。在训练任何随机机器学习模型时，会有一些差异。如果你要在数百次运行中平均这些结果，它们将（大致）相同。

来源： https://www.pyimagesearch.com/2017/10/30/how-to-multi-gpu-training-with-keras-python-and-deep-learning/