gpu编程如何一步步学习_如何使用keras，python和深度学习进行多GPU训练

最新推荐文章于 2024-05-20 05:57:09 发布

weixin_39960710

最新推荐文章于 2024-05-20 05:57:09 发布

阅读量146

点赞数

点击上方“Python数据科学”，星标公众号

重磅干货，第一时间送达

☞满600减350，当当这波羊毛我撸定了！

作者：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 MiniGoogLeNetfrom sklearn.preprocessing import LabelBinarizerfrom keras.preprocessing.image import ImageDataGeneratorfrom keras.callbacks import LearningRateSchedulerfrom keras.utils.training_utils import multi_gpu_modelfrom keras.optimizers import SGDfrom keras.datasets import cifar10import matplotlib.pyplot as pltimport tensorflow as tfimport numpy as npimport 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 = 70INIT_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 -= meantestX -= 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.5983Epoch 2/70 - 63s - loss: 1.0279 - acc: 0.6361 - val_loss: 0.9844 - val_acc: 0.6472Epoch 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.9069Epoch 69/70 - 63s - loss: 0.0348 - acc: 0.9898 - val_loss: 0.3593 - val_acc: 0.9080Epoch 70/70 - 63s - loss: 0.0340 - acc: 0.9900 - val_loss: 0.3583 - val_acc: 0.9065Using TensorFlow backend. real    74m10.603suser    131m24.035ssys     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.5026Epoch 2/70 - 16s - loss: 1.2814 - acc: 0.5356 - val_loss: 1.1252 - val_acc: 0.5998Epoch 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.8852Epoch 69/70 - 16s - loss: 0.1605 - acc: 0.9466 - val_loss: 0.3604 - val_acc: 0.8863Epoch 70/70 - 16s - loss: 0.1569 - acc: 0.9487 - val_loss: 0.3603 - val_acc: 0.8877Using TensorFlow backend. real    19m3.318suser    104m3.270ssys     7m48.890s