资源 | 博士生开源深度学习C++库DLL：快速构建卷积受限玻尔兹曼 Baptiste Wicht公布了自己编写的深度学

选自baptiste-wicht

机器之心编译

参与：刘晓坤、蒋思源

Baptiste Wicht公布了自己编写的深度学习库DLL1.0，可以通过C++接口使用。文中通过几个例子介绍了DLL调用全连接网络、DNN的能力，并通过实验和其它流行框架如TensorFlow、Keras、Torch和Caffe作了综合性能比较。

很高兴公布深度学习库 Deep Learning Library（DLL）1.0 的第一个版本。DLL 是一个神经网络库，致力于提供快速和易用的使用体验。

项目地址：http://github.com/wichtounet/dll

我从四年前为完成 Ph.D. 论文而开始搭建这个库。我需要一个好用的库来训练和使用受限玻尔兹曼机（RBMs），而当时并没有这样的条件。因此，我决定自己编写。现在它能很完美的支持 RBM 和卷积 RBM（CRBM）模型。RBMs（或深度信念网络，DBNs）的堆栈可以用对比分歧（Contrastive Divergence）预训练，然后用 mini-batch 梯度下降或共轭梯度法进行微调，或者直接作为特征提取器。经过多年发展，该库已经扩展到可以处理人工神经网络（ANNs）和卷积神经网络（CNNs）了。其中网络还可以训练常规的自动编码器。还能使用多种高级层比如 Dropout 或 Batch 正则化，以及自适应学习率技术比如 Adadelta 和 Adam。这个库还能集成支持这几个数据集：MNIST，CIFAR-10 和 ImageNet。

这个库可以通过 C++接口使用，完全的仅有标头档（fully header-only），需要 C++14 编译器，即至少需要 clang3.9 或 GCC6.3。

调用案例

我们先看看下面这个使用库的例子：

#include "dll/neural/dense_layer.hpp"

#include "dll/network.hpp"

#include "dll/datasets.hpp"

int main(int /*argc*/, char* /*argv*/ []) {

// Load the dataset

auto dataset = dll::make_mnist_dataset(dll::batch_size<100>{}, dll::normalize_pre{});

// Build the network

using network_t = dll::dyn_network_desc<

dll::network_layers<

dll::dense_layer<28 * 28, 500>,

dll::dense_layer<500, 250>,

dll::dense_layer<250, 10, dll::softmax>

, dll::updater<dll::updater_type::NADAM> // Nesterov Adam (NADAM)

, dll::batch_size<100> // The mini-batch size

, dll::shuffle // Shuffle before each epoch

>::network_t;

auto net = std::make_unique<network_t>();

// Train the network for performance sake

net->fine_tune(dataset.train(), 50);

// Test the network on test set

net->evaluate(dataset.test());

return 0;

}

这个例子是在 MNIST 数据集上训练并测试的简单 3 层全连接神经网络。

首先，对于头文件（include），你需要包含你将使用的层，在这个例子中只有密集层（dense layer）。然后，你需要包含 network.hpp，这是每一个网络的基本头文件。而且最后的标头就是数据集支持。

在 main 函数中，首先需要加载全部 MNIST 数据集，然后给出两个选项（该函数有一系列可选的参数）。在这里，我们设置批量大小，并指示每一个样本都必须归一化为平均值为 0，方差为 1。

之后是很重要的部分，即网络的声明。在 DLL 中，一个网络是一个类型（type）。类型有两个性质，层（layers，包含在 dll::network_layers 中），和选项（options，一系列参数选项），跟随层之后。在这个例子中，我们声明了三个层，第一层有 500 个隐藏单元，第二层有 250 个，而最后一层有 10 个。每一层都有一系列参数选项。最后一层使用 Softmax 激活函数，而不是默认的 Sigmoid 函数。网络本身有 3 个选项。我们将使用 Nesterov Adam（NAdam）优化器，批量大小为 100（必须等于前面数据集提取时声明的批量大小），而在每一个 epoch 之前数据集将被重组（shuffled）。

然后，我们将简单地使用 std::make_unique 命令创建该网络，在训练集上训练 50 个 epoch，并在测试集上测试。

以下是该网络的代码：

Network with 3 layers

Dense(dyn): 784 -> SIGMOID -> 500

Dense(dyn): 500 -> SIGMOID -> 250

Dense(dyn): 250 -> SOFTMAX -> 10

Total parameters: 519500

Dataset

Training: In-Memory Data Generator

Size: 60000

Batches: 600

Augmented Size: 60000

Testing: In-Memory Data Generator

Size: 10000

Batches: 100

Augmented Size: 10000

Train the network with "Stochastic Gradient Descent"

Updater: NADAM

Loss: CATEGORICAL_CROSS_ENTROPY

Early Stop: Goal(error)

With parameters:

epochs=50

batch_size=100

learning_rate=0.002

beta1=0.9

beta2=0.999

Epoch 0/50 - Classification error: 0.03248 Loss: 0.11162 Time 3187ms

Epoch 1/50 - Classification error: 0.02737 Loss: 0.08670 Time 3063ms

Epoch 2/50 - Classification error: 0.01517 Loss: 0.04954 Time 3540ms

Epoch 3/50 - Classification error: 0.01022 Loss: 0.03284 Time 2954ms

Epoch 4/50 - Classification error: 0.00625 Loss: 0.02122 Time 2936ms

Epoch 5/50 - Classification error: 0.00797 Loss: 0.02463 Time 2729ms

Epoch 6/50 - Classification error: 0.00668 Loss: 0.02066 Time 2921ms

Epoch 7/50 - Classification error: 0.00953 Loss: 0.02710 Time 2894ms

Epoch 8/50 - Classification error: 0.00565 Loss: 0.01666 Time 2703ms

Epoch 9/50 - Classification error: 0.00562 Loss: 0.01644 Time 2759ms

Epoch 10/50 - Classification error: 0.00595 Loss: 0.01789 Time 2572ms

Epoch 11/50 - Classification error: 0.00555 Loss: 0.01734 Time 2586ms

Epoch 12/50 - Classification error: 0.00505 Loss: 0.01446 Time 2575ms

Epoch 13/50 - Classification error: 0.00600 Loss: 0.01727 Time 2644ms

Epoch 14/50 - Classification error: 0.00327 Loss: 0.00898 Time 2636ms

Epoch 15/50 - Classification error: 0.00392 Loss: 0.01180 Time 2660ms

Epoch 16/50 - Classification error: 0.00403 Loss: 0.01231 Time 2587ms

Epoch 17/50 - Classification error: 0.00445 Loss: 0.01307 Time 2566ms

Epoch 18/50 - Classification error: 0.00297 Loss: 0.00831 Time 2857ms

Epoch 19/50 - Classification error: 0.00335 Loss: 0.01001 Time 2931ms

Epoch 20/50 - Classification error: 0.00378 Loss: 0.01081 Time 2772ms

Epoch 21/50 - Classification error: 0.00332 Loss: 0.00950 Time 2964ms

Epoch 22/50 - Classification error: 0.00400 Loss: 0.01210 Time 2773ms

Epoch 23/50 - Classification error: 0.00393 Loss: 0.01081 Time 2721ms

Epoch 24/50 - Classification error: 0.00415 Loss: 0.01218 Time 2595ms

Epoch 25/50 - Classification error: 0.00347 Loss: 0.00947 Time 2604ms

Epoch 26/50 - Classification error: 0.00535 Loss: 0.01544 Time 3005ms

Epoch 27/50 - Classification error: 0.00272 Loss: 0.00828 Time 2716ms

Epoch 28/50 - Classification error: 0.00422 Loss: 0.01211 Time 2614ms

Epoch 29/50 - Classification error: 0.00417 Loss: 0.01148 Time 2701ms

Epoch 30/50 - Classification error: 0.00498 Loss: 0.01439 Time 2561ms

Epoch 31/50 - Classification error: 0.00385 Loss: 0.01085 Time 2704ms

Epoch 32/50 - Classification error: 0.00305 Loss: 0.00879 Time 2618ms

Epoch 33/50 - Classification error: 0.00343 Loss: 0.00889 Time 2843ms

Epoch 34/50 - Classification error: 0.00292 Loss: 0.00833 Time 2887ms

Epoch 35/50 - Classification error: 0.00327 Loss: 0.00895 Time 2644ms

Epoch 36/50 - Classification error: 0.00203 Loss: 0.00623 Time 2658ms

Epoch 37/50 - Classification error: 0.00233 Loss: 0.00676 Time 2685ms

Epoch 38/50 - Classification error: 0.00298 Loss: 0.00818 Time 2948ms

Epoch 39/50 - Classification error: 0.00410 Loss: 0.01195 Time 2778ms

Epoch 40/50 - Classification error: 0.00173 Loss: 0.00495 Time 2843ms

Epoch 41/50 - Classification error: 0.00232 Loss: 0.00709 Time 2743ms

Epoch 42/50 - Classification error: 0.00292 Loss: 0.00861 Time 2873ms

Epoch 43/50 - Classification error: 0.00483 Loss: 0.01365 Time 2887ms

Epoch 44/50 - Classification error: 0.00240 Loss: 0.00694 Time 2918ms

Epoch 45/50 - Classification error: 0.00247 Loss: 0.00734 Time 2885ms

Epoch 46/50 - Classification error: 0.00278 Loss: 0.00725 Time 2785ms

Epoch 47/50 - Classification error: 0.00262 Loss: 0.00687 Time 2842ms

Epoch 48/50 - Classification error: 0.00352 Loss: 0.01002 Time 2665ms

Epoch 49/50 - Classification error: 0.00232 Loss: 0.00668 Time 2747ms

Restore the best (error) weights from epoch 40

Training took 142s

error: 0.02040

loss: 0.08889

首先正如代码中所示，是网络和数据集的展示，然后是网络的训练过程的每一个 epoch 的信息，最后是评估的结果。在大约 2 分半的时间内就能训练一个可以识别 MNIST 数字的网络，而错误率是 2.04%，这个结果不错，但还能继续优化。

简单介绍一下如何编译。可以直接使用 sudo make install_headers 命令下载 dll 库到你计算机 checked-out dll 文件夹上，然后使用一下命令对文件进行简单的编译:

clang++ -std=c++14 file.cpp

或者，如果需要将 dll 复制到本地的 dll 目录中，你需要具体说明头文件的文件夹：

clang++ -std=c++14 -Idll/include -Idll/etl/lib/include -dll/Ietl/include/ -Idll/mnist/include/ -Idll/cifar-10/include/ file.cpp

以下几个编译选项可以帮助你提升性能：

-DETL_PARALLEL：允许并行计算

-DETL_VECTORIZE_FULL：允许算法的完全向量化

-DETL_BLAS_MODE：将使该库 know about 一个 BLAS 库（比如 MKL），你必须为 BLAS 库添加一个头文件选项和连接选项作为可选项。

-DETL_CUBLAS_MODE：使该库知道 NVIDIA cublas 是可用的，必须添加合适的选项（头文件目录和连接库）

-DETL_CUDNN_MODE：使该库知道 NVIDIA cudnn 是可用的，必须添加合适的选项（头文件目录和连接库）

-DETL_EGBLAS_MODE：使该库知道你安装了 etl-gpu-blas，必须添加合适的选项（头文件目录和连接库）

如果想要得到最佳的 CPU 性能，需要用到前面 3 个选项。如果想要得到最佳的 GPU 性能，需要用到后面 3 个选项。由于有些算法并不是完全在 GPU 上计算的，最好使用所有的选项。

接下来我们重复上述实验，但这次使用的是一个包含两个卷积层和两个池化层的卷积神经网络：

#include "dll/neural/conv_layer.hpp"

#include "dll/neural/dense_layer.hpp"

#include "dll/pooling/mp_layer.hpp"

#include "dll/network.hpp"

#include "dll/datasets.hpp"

#include "mnist/mnist_reader.hpp"

#include "mnist/mnist_utils.hpp"

int main(int /*argc*/, char* /*argv*/ []) {

// Load the dataset

auto dataset = dll::make_mnist_dataset(dll::batch_size<100>{}, dll::scale_pre<255>{});

// Build the network

using network_t = dll::dyn_network_desc<

dll::network_layers<

dll::conv_layer<1, 28, 28, 8, 5, 5>,

dll::mp_2d_layer<8, 24, 24, 2, 2>,

dll::conv_layer<8, 12, 12, 8, 5, 5>,

dll::mp_2d_layer<8, 8, 8, 2, 2>,

dll::dense_layer<8 * 4 * 4, 150>,

dll::dense_layer<150, 10, dll::softmax>

, dll::updater<dll::updater_type::NADAM> // Momentum

, dll::batch_size<100> // The mini-batch size

, dll::shuffle // Shuffle the dataset before each epoch

>::network_t;

auto net = std::make_unique<network_t>();

// Display the network and dataset

net->display();

dataset.display();

// Train the network

net->fine_tune(dataset.train(), 25);

// Test the network on test set

net->evaluate(dataset.test());

return 0;

}

比起之前的例子来看并没有太多变化。这个网络起始于一个卷积层，然后是一个池化层，然后又是一个卷积层和池化层，最后是两个全连接层。另一个区别是我们将输入除以 255（（dll::scale_pre<255>{}））而不是归一化。最后，我们只训练了 25 个 epoch。

一旦进行编译和运行，结果将是如下所示的样子：

Network with 6 layers

Conv(dyn): 1x28x28 -> (8x5x5) -> SIGMOID -> 8x24x24

MP(2d): 8x24x24 -> (2x2) -> 8x12x12

Conv(dyn): 8x12x12 -> (8x5x5) -> SIGMOID -> 8x8x8

MP(2d): 8x8x8 -> (2x2) -> 8x4x4

Dense(dyn): 128 -> SIGMOID -> 150

Dense(dyn): 150 -> SOFTMAX -> 10

Total parameters: 21100

Dataset

Training: In-Memory Data Generator

Size: 60000

Batches: 600

Augmented Size: 60000

Testing: In-Memory Data Generator

Size: 10000

Batches: 100

Augmented Size: 10000

Train the network with "Stochastic Gradient Descent"

Updater: NADAM

Loss: CATEGORICAL_CROSS_ENTROPY

Early Stop: Goal(error)

With parameters:

epochs=25

batch_size=100

learning_rate=0.002

beta1=0.9

beta2=0.999

Epoch 0/25 - Classification error: 0.09392 Loss: 0.31740 Time 7298ms

Epoch 1/25 - Classification error: 0.07005 Loss: 0.23473 Time 7298ms

Epoch 2/25 - Classification error: 0.06915 Loss: 0.22532 Time 7364ms

Epoch 3/25 - Classification error: 0.04750 Loss: 0.15286 Time 7787ms

Epoch 4/25 - Classification error: 0.04082 Loss: 0.13191 Time 7377ms

Epoch 5/25 - Classification error: 0.03258 Loss: 0.10283 Time 7334ms

Epoch 6/25 - Classification error: 0.03032 Loss: 0.09791 Time 7304ms

Epoch 7/25 - Classification error: 0.02727 Loss: 0.08453 Time 7345ms

Epoch 8/25 - Classification error: 0.02410 Loss: 0.07641 Time 7443ms

Epoch 9/25 - Classification error: 0.02448 Loss: 0.07612 Time 7747ms

Epoch 10/25 - Classification error: 0.02023 Loss: 0.06370 Time 7626ms

Epoch 11/25 - Classification error: 0.01920 Loss: 0.06194 Time 7364ms

Epoch 12/25 - Classification error: 0.01810 Loss: 0.05851 Time 7391ms

Epoch 13/25 - Classification error: 0.01575 Loss: 0.05074 Time 7316ms

Epoch 14/25 - Classification error: 0.01542 Loss: 0.04826 Time 7365ms

Epoch 15/25 - Classification error: 0.01392 Loss: 0.04574 Time 7634ms

Epoch 16/25 - Classification error: 0.01287 Loss: 0.04061 Time 7367ms

Epoch 17/25 - Classification error: 0.01167 Loss: 0.03779 Time 7381ms

Epoch 18/25 - Classification error: 0.01202 Loss: 0.03715 Time 7495ms

Epoch 19/25 - Classification error: 0.00967 Loss: 0.03268 Time 7359ms

Epoch 20/25 - Classification error: 0.00955 Loss: 0.03012 Time 7344ms

Epoch 21/25 - Classification error: 0.00853 Loss: 0.02809 Time 7314ms

Epoch 22/25 - Classification error: 0.00832 Loss: 0.02834 Time 7329ms

Epoch 23/25 - Classification error: 0.00807 Loss: 0.02603 Time 7336ms

Epoch 24/25 - Classification error: 0.00682 Loss: 0.02327 Time 7335ms

Training took 186s

error: 0.01520

loss: 0.05183

这个网络比之前的稍微要好一些，在 3 分钟的时间里达到了 1.52% 的错误率。如果你感兴趣的话，可以在 Github 中找到更多的例子。

性能

如果你看过我最新的博客，那么你可能已经看过以下部分信息，但我仍然想在这里强调一下。我在 DLL 库的性能表现上做了大量工作。我决定将 DLL 的性能和流行的框架如 TensorFlow、Keras、Torch 和 Caffe 做个对比。我也试过 DeepLearning4J，但出现了很多问题使我不得不先放弃它。如果有人对其中的结果有兴趣我也可以在某个网站发布。所有的框架都以默认选项安装，并且都可以使用 MKL。

第一个实验是在 MNIST 数据集上训练一个 3 层网络：

对于 CPU，DLL 训练这个网络是最快的。比 TensorFlow 和 Keras 快大约 35%，比 Torch 快 4 倍，比 Caffe 快 5 倍。而对于 GPU，Caffe 是最快的，紧接着是 Keras，TensorFlow 和 DLL，而 Torch 是最慢的。

以下是在同样的任务中使用 CNN 训练的结果：

再一次，对于 CPU，DLL 是最快的，非常明显，比起 TensorFlow 和 Keras 快 4 倍，比 Torch 和 Caffe 快 5 倍。对于 GPU，DLL 和 TensorFlow 以及 Keras 持平，比 Caffe 快 3 倍，比 Torch 快 5 倍。

以下是在 CIFAR-10 上用更大的 CNN 训练的结果：

在更大的 CNN 中，区别没有之前的那么明显，尽管如此，对于 CPU，DLL 仍然是最快的，比 TensorFlow、Keras 和 Torch 快两倍，比 Caffe 快 3 倍。对于 GPU，DLL 比 TensorFlow 和 Keras 稍快，比 Caffe 快 2.7 倍，比 Torch 快 5 倍。

最后一个实验是在 Imagenet 上用 12 层的 CNN 训练。mini-batch 设置为 128。

DLL 无论是在 CPU 还是 GPU 上都比其它所有框架要快。DLL 和 TensorFlow、Keras 的最大的不同主要是由于用 Python 代码读取 ImageNet 的图片的能力很差，而 DLL 中的代码已经优化过。

综上，在所有的实验中，DLL 的 CPU 计算都是最快的。对于 GPU，除了超小型全连接神经网络，DLL 也总是最快的，和 TensorFlow、Keras 并驾齐驱。

如果感兴趣，可以在这里找到实验的代码：http://github.com/wichtounet/frameworks

下一步

我并不知道下一个版本的 DLL 将具体包括哪些函数，但我知道它在以后的发展方向。

我真的希望能使用 DLL 执行文本分类任务。计划第一步将支持文本的嵌入学习，并在嵌入上使用 CNN。我同样计划添加支持合并 CNN 层的能力，从而我们能使用各种大小的滤波器，希望第一步不要花太多时间。第二步希望将循环神经网络（RNN）纳入该框架中。当然首先只会支持简单的 RNN 单元，但后来会添加 LSTM 单元和 GRU 单元的支持。这一部分肯定需要很长的时间，但我真的希望能通过这个理解这些循环神经网络的原理到底是什么。

我关注的下一件事是该神经网络库的文档构建。当然现在使用案例来了解各种函数的用法是比较好的，但还是需要列出可能的神经网络层函数和它们所有的可选参数。我还希望能有更多的实现案例，特别是当添加嵌入和 RNN 支持的时候。

此外，虽然性能一般来说还是不错的，但还有一些地方需要改进。例如目前很多运算（如批量归一化和 Dropout）在 GPU 上是比较低效的，我希望所有运算在 GPU 中都能高效地执行。还有一些运算如批量归一化或 SGD 优化器等在 CPU 上运行比较低效，所以我还需要解决这一些问题。理想的情况是，即使不使用性能库，DLL 也能表现的比较好。

最后，我还希望能提升编译时间。虽然最近的修正已经令 DLL 程序的编译过程更加快速，但我还希望取得更快的速度。

下载 DLL

读者可以在 GitHub 中下载 DLL，如果你们对 1.0 版本比较感兴趣，可以直接查看发布页面（Releases pages）或复制 tag 1.0。下面还有一些分支：

master 是永远的开发分支，可能并不是太稳定

stable 分支永远指向最新的 tag，并不会经常更新

对于未来的版本，总会有 tag 指向对应的 commits，你可以通过 GitHub 或发布的 tag 访问以前的版本。

对于文档，当前最好的文档说明是目前可用的实现案例。你可以查看测试案例的源代码，其中该软件库每一个函数都得到了使用。如果这一次开发的神经网络库得到较多的关注，后面我们将关注文档的构建。

原文链接：http://baptiste-wicht.com/posts/2017/10/deep-learning-library-10-fast-neural-network-library.html

本文为机器之心编译，转载请联系本公众号获得授权。

?------------------------------------------------

加入机器之心（全职记者/实习生）：hr@jiqizhixin.com

投稿或寻求报道：content@jiqizhixin.com

广告&商务合作：bd@jiqizhixin.com