本文深入剖析Darknet训练网络过程，涵盖CPU、单GPU及多GPU模式，详解train_network()函数，探讨不同模式下的数据处理、并行计算及多GPU同步策略。
系列目录
darknet 源码阅读(零) - Entry Point
darknet 源码阅读(一) - 解析网络配置文件 cfg
darknet 源码阅读(二) - 加载训练样本数据
darknet 源码阅读(三) - 训练网络
darknet 源码阅读(番外篇一) - 卷积层
本文围绕 train_network() 函数分析 darknet 如何完成一个完整的训练过程. train_network() 函数的完整实现参考: https://github.com/pjreddie/darknet/blob/master/src/network.c.
根据运算单元的不同, 分为 GPU 和 CPU 训练. 其中, 对于 GPU 训练, 根据 GPU 个数的多少, 又可分为单 GPU 和多 GPU 训练.
需要说明的是: 在开始训练之前, 数据和神经网络结构(train 和 net 变量)都已经准备完毕, 训练完成后返回 loss 的值.
下面是三种不同情况的调用代码.
#ifdef GPU
if(ngpus == 1){ // 单 GPU 模式
loss = train_network(net, train);
} else { // 多 GPU 模式
loss = train_networks(nets, ngpus, train, 4);
}
#else // CPU 模式
loss = train_network(net, train);
#endif
1. CPU 训练网络
CPU 训练对应的函数是 train_network(net, train), 训练使用的是 batch 随机梯度下降法. 以下进行详细的函数功能分析.
1.1 图片数量和 batch 的数量一致性
需要注意的是: 在 darknet 中, 读取的图片数量和 batch 的数量必须一致.
在这篇博客: darknet 源码阅读(一) - 解析网络配置文件 cfg 中对 batch 和 subdivision 参数的含义做了详细描述. 总结一下:
// batch 被均分为 subdivisions 份, 成为更小的 batch.
net->batch /= net->subdivisions;
...
int imgs = net->batch * net->subdivisions * ngpus;
其中 imgs 就是最终要加载的图片数量. 对于 CPU 和 单 GPU 模式, ngpus 的值为 1.
加载图片使用的线程数目为 64, 除最后一个线程外, imgs 被平分到每一个线程上分别加载, 最后一个线程分配到的图片数量一定不大于前面 63 个线程. 因此, imgs 不需要被 64 整除.
但是 assert(d.X.rows % net->batch == 0); 表示 d.X.rows 必须能被 net->batch 整除. 其中 d.X.rows 是本次训练的图片 batch 数量, 即 imgs, 因此, 在设置配置文件参数时, 设置的 batch 值应该可以被subdivisions 整除.
1.2 实际训练过程中的 batch 到底为多大?
完整的回答一下这个问题. 1.1 节中提到:
net->batch /= net->subdivisions;
batch_size 被均分为 subdivisions 份, 成为更小的 batch, 因此实际训练过程中的 batch_size 为 net->batch / net->subdivisions.
为什么? 答案就在 train_network() 函数中.
int batch = net->batch; // batch_size, = batch / subdivisions
int n = d.X.rows / batch; // batch 个数, 对于单 GPU 和 CPU, n = subdivision
至此, batch_size 已经确定, batch 的个数 n 也确定. 可以开始训练了.
1.3 按批次 batch 开始训练
训练过程是让网络学习到最优的权重值. 因此, 在训练之前必须准备好监督学习所必需的数据: 样本和 label. 即 net->input, 和 net->truth. 这个工作由 get_next_batch() 函数完成.
get_next_batch() 函数的工作本质上就是按照 batch 从加载好的数据(保存在 train 变量中)中拷贝数据, 由于函数功能比较简单, 这里就不展开分析了.
样本和 label 准备好之后就可以正式开始训练了. 训练工作由 train_network_datum() 函数完成. 以下贴出 train_network_datum() 函数代码.
float train_network_datum(network *net)
{
*net->seen += net->batch; // 累加每次训练的 batch_size
net->train = 1; // 标记当前处于训练阶段
forward_network(net); // 执行前向运算
backward_network(net); // 执行反向传播
float error = *net->cost; // 获取 loss 值
if(((*net->seen)/net->batch)%net->subdivisions == 0)
update_network(net); // 更新训练参数: 学习率,优化方法,衰减率等
return error;
}
net->train = 1; 表示当前处理训练阶段; 如果处于测试阶段, net->train = 0;
训练过程很清晰: 先执行前向运算, 然后执行反向传播. 下面会对这两个函数详细展开分析.
反向传播完成之后, 需要在适当的条件下更新网络. net->seen 变量决定了是否更新网络, 那这个 net->seen 表示什么?
net->seen 表示从训练器开始运行到当前时刻已经训练的图像张数. 最终保存模型时的迭代次数就是根据 net->seen 计算得到的.
如果使用之前已经训练过的模型做微调, 但又不想使用之前模型中保存下的 seen 变量值, 可以在训练命令行使用 “-clear” 参数.
int clear = find_arg(argc, argv, "-clear"); // 清空 net->seen 变量的值
...
if(clear) (*net->seen) = 0;
1.3.1 前向运算 - forward_network
前向运算其实就是遍历网络的所有层, 按照不同类型层定义的运算规则得到最终输出层的输出. 前向运算从输入层开始直到输出层, 最后根据前向运算结果和对应输入的 label 来计算代价函数的值, 以此作为反向传播的依据.
网络是由一个个 layer 组成的, 网络的前向运算归根结底还是每个 layer 定义的前向运算.
void forward_network(network *netp)
{
#ifdef GPU
if(netp->gpu_index >= 0){
forward_network_gpu(netp); // GPU 执行前向运算
return;
}
#endif
// 遍历网络中的所有层, 完成前向运算
network net = *netp;
int i;
for(i = 0; i < net.n; ++i){
net.index = i;
layer l = net.layers[i];
if(l.delta){
fill_cpu(l.outputs * l.batch, 0, l.delta, 1);
}
l.forward(l, net); // CPU 执行前向运算
net.input = l.output; // 上一层的输出为下一层的输入
if(l.truth) {
net.truth = l.output;
}
}
calc_network_cost(netp); // 计算 loss 值;
}
前向运算由 void (*forward) (struct layer, struct network) 函数定义, 以卷积层为例, forward 函数指针为 forward_convolutional_layer(). 关于卷积层的前向运算可以参考这篇博客: darknet 源码阅读(番外篇一) - 卷积层.
每一层的前向运算完成之后, 该层的输出就是下一层的输入. 依次进行直到输出层. 当所有的层的前向运算全部完成之后, 通过 calc_network_cost() 函数计算所有层的 cost 平均值作为本次前向运算的误差. 该误差用于直到反向传播运算.
1.3.2 反向传播 - backward_network
需要注意的是, 某些层可以跳过反向传播计算.
关于卷积层的反向传播可以参考这篇博客: darknet 源码阅读(番外篇一) - 卷积层.
1.3.3 更新网络 - update_network
更新网络其实是在更新训练参数. 需要被更新的训练参数有: batch_size, 学习率, 动量值, 衰减率, 优化方法, B1, B2, eps, t; 不同类型的层的更新策略互不相同. 关于卷积层的更新可以参考这篇博客: darknet 源码阅读(番外篇一) - 卷积层.
if(((*net->seen)/net->batch)%net->subdivisions == 0)
update_network(net);
在这篇文章中提到过: batch_size 被 subdivision 均分为更小的 batch_size 之后才送入训练器中训练. 那为什么要这么做呢? 为什么不直接就定义一个比较小的 batch 作为 batch_size 呢?
这是因为过小的 batch 会使得每次计算出的 loss 的值的波动比较大, 采用这种方式可以使较多的前向运算 cost 参与 loss 值的计算, 从而减少 loss 的波动. 这应该算是一种训练的 trick 吧.
另外, subdivision 还有一个作用就是避免频繁的更新训练参数. 只有在训练次数达到 net->batch * net->subdivisions 之后才会更新训练参数.
至此, CPU 模式下的一个 batch 的训练迭代就完成了, train_network() 函数的返回值 loss 涉及到两次平均. (1) 是 batch_size 个样本每一层的 loss 的平均值; (2) (1) 中得到的 subdivision 个小 batch_size 的 loss 再平均.
2. 单 GPU 训练网络
其实对于只想了解训练过程的读者来说, CPU 模式的训练就完整的描述了整个训练过程. CPU 和 GPU 的不同之处就在于数据在内存空间的处理和并行计算架构 cuda 的编程. 因此, 对应的函数名是在 CPU 函数名的后缀部分增加了 “_gpu”.
关于 CPU 和 GPU 之间的内存空间处理相关的函数是: cuda_push_array();
单 GPU 模式下前向运算使用的是 forward_network_gpu(), 反向传播使用的是 backward_network_gpu(), 更新网络使用的是 update_network_gpu().
3. 多 GPU 训练网络
与单 GPU 训练不同的是, 在使用多 GPU 训练网络时, 需要注意多个 GPU 之间的数据同步操作. darknet 中使用 train_networks() 实现多 GPU 的网络训练任务.
/**
* \brief 多 GPU 的训练函数
*
* \param nets: 训练使用的网络,多个 GPU 使用相同的网络;在解析网络配置文件时被填充
* n: GPU 的个数;
* d: 加载好的样本数据和标签数据;
* interval: 网络同步更新所需的 batch 间隔;
*
* \return loss 值;
*/
float train_networks(network **nets, int n, data d, int interval)
{
int i;
int batch = nets[0]->batch;
int subdivisions = nets[0]->subdivisions;
assert(batch * subdivisions * n == d.X.rows);
pthread_t *threads = (pthread_t *) calloc(n, sizeof(pthread_t));
float *errors = (float *) calloc(n, sizeof(float));
// 单 GPU 模式下训练网络
float sum = 0;
for(i = 0; i < n; ++i){
data p = get_data_part(d, i, n);
threads[i] = train_network_in_thread(nets[i], p, errors + i);
}
for(i = 0; i < n; ++i){
pthread_join(threads[i], 0);
//printf("%f\n", errors[i]);
sum += errors[i]; // 计算网络的 loss 值
}
// 更新网络中的 seen, w 和 b 参数值
if (get_current_batch(nets[0]) % interval == 0) {
printf("Syncing... ");
fflush(stdout);
sync_nets(nets, n, interval);
printf("Done!\n");
}
free(threads);
free(errors);
return (float)sum/(n);
}
首先, 每个 GPU 作为单 GPU 使用相同的网络参数独立训练. 因此, train_network_in_thread() 函数最终调用到的还是单 GPU 训练时使用的网络训练函数: train_network(); 函数调用流程如下: train_network_in_thread -> train_thread() -> train_network().
最后, 多个 GPU 的训练全部结束后, 对多个 GPU 的训练结果(loss 值)求平均值即可.
可能在适当的时机需要同步更新多个 GPU 使用的网络. 比如网络已经训练的图片数目 = 单个 GPU 训练的图片数目 * GPU 个数, interval 用来控制更新的频率, darknet 中设置的是 4. 为了加快同步速度, 使用多个线程来按层同步网络. 同步更新每一层的函数为 sync_layer(), 接下来看看这个函数到底做了什么.
void sync_layer(network **nets, int n, int j)
{
int i;
network *net = nets[0];
layer base = net->layers[j];
scale_weights(base, 0); // 将该层的 w 和 b 参数全部置零.
// 合并多个 GPU 训练得到的 w 和 b 值;
for (i = 0; i < n; ++i) {
cuda_set_device(nets[i]->gpu_index);
layer l = nets[i]->layers[j];
pull_weights(l); // 将 w 和 b 参数对应的 xxx_updates 更新到 xxx_gpu 中;
merge_weights(l, base); // 执行矩阵的加法运算
}
scale_weights(base, 1./n); // 求多个 GPU 中的 w 和 b 的平均值;
for (i = 0; i < n; ++i) {
cuda_set_device(nets[i]->gpu_index);
layer l = nets[i]->layers[j];
distribute_weights(l, base);
}
}
下面介绍一下这个函数中的几个子函数.
-
scale_weights() 是对 w 和 b 参数进行常数乘法运算. scale_weights(base, 0) 其实就是将该层的 w 和 b 参数全部置零.
-
pull_weights() 是将某一层中的 bias_updates 和 weight_updates 的数据更新到 biases_gpu 和 weights_gpu 中.
-
merge_weights(layer l, layer base) 是执行矩阵的加法运算, 将运算结果保存在 base 中.
-
distribute_weights(layer l, layer base) 是将 base 中的 biases 和 weights 赋值给 l 中对应的变量中.
因此, sync_layer() 只做了三个参数 ( seen, w 和 b ) 的更新. (1) 网络以训练的图片数目 net->seen; (2) 对多个 GPU 训练得到的权值 w 和 b 做平均之后作为网络下一次训练的权值.
4. 总结
本文从 CPU 和 GPU 模式分别分析了 darknet 训练网络的过程. 对于 CPU 模式和单 GPU 模式的前向运算和反向传播, 除了使用不同的计算单元来完成相应的运算之外, GPU 模式下的前向运算需要先进行系统内存到显存的数据拷贝, 反向传播需要将计算得到的显存数据拷贝到系统内存空间.
对于多 GPU 模式, 除了执行单 GPU 的独立运算之外, 需要每隔一段时间将多个 GPU 计算得到的权值结果进行平均后重新分配.
扫一扫
6577
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
