【darknet源码】：网络前向，反向，更新源码

蔚落 2022-05-17 01:22 292阅读 0赞

前向过程：  
**network.c/train\_network()–>network.c/train\_network\_datum()–>network.c/forward\_network()**  
反向过程：  
**network.c/train\_network()–>network.c/train\_network\_datum()–>network.c/backward\_network()**  
更新网络过程：  
**network.c/train\_network()–>network.c/train\_network\_datum()–>network.c/update\_network()**

#### 1. network.c/train\_network() ####

/*
    ** 训练一个batch（此处所指一个batch含有的图片是配置文件中真实指定的一个batch中含有的图片数量，也即图片张数为：net.batch*net.subdivision）
    ** 输入： net     已经构建好待训练的整个网络
    **       d       此番训练所用到的所有图片数据（包含net.batch*net.subdivision张图片）
    ** 说明：train_network()函数对应处理ngpu=1的情况，如果有多个gpu，那么会首先调用train_networks()函数，在其之中会调用get_data_part()
    **      将在detector.c train_detector()函数中读入的net.batch*net.subdivision*ngpu张图片平分至每个gpu上，
    **      而后再调用train_network()，总之最后train_work()的输入d中只包含net.batch*net.subdivision张图片
    */
    float train_network(network net, data d)
    {
        // 事实上对于图像检测而言，d.X.rows/net.batch=net.subdivision，因此恒有d.X.rows % net.batch == 0，且下面的n就等于net.subdivision
        // （可以参看detector.c中的train_detector()），因此对于图像检测而言，下面三句略有冗余，但对于其他种情况（比如其他应用，非图像检测甚至非视觉情况），
        // 不知道是不是这样
        assert(d.X.rows % net.batch == 0);
        int batch = net.batch;
        int n = d.X.rows / batch;
    
        int i;
        float sum = 0;
        for(i = 0; i < n; ++i){
            // 从d中读取batch张图片到net.input中，进行训练
            // 第一个参数d包含了net.batch*net.subdivision张图片的数据，第二个参数batch即为每次循环读入到net.input也即参与train_network_datum()
            // 训练的图片张数，第三个参数为在d中的偏移量，第四个参数为网络的输入数据，第五个参数为输入数据net.input对应的标签数据（真实数据）
            get_next_batch(d, batch, i*batch, net.input, net.truth);
    
            // 训练网络：本次训练的数据共有net.batch张图片。
            // 训练包括一次前向过程：计算每一层网络的输出并计算cost；一次反向过程：计算敏感度、权重更新值、偏置更新值；适时更新过程：更新权重与偏置
            float err = train_network_datum(net);
            sum += err;
        }
        return (float)sum/(n*batch);
    }

#### 2. network.c/train\_network\_datum() ####

float train_network_datum(network net)
    {
        // 如果使用GPU则调用gpu版的train_network_datum
    #ifdef GPU
        if(gpu_index >= 0) return train_network_datum_gpu(net);
    #endif
        // 更新目前已经处理的图片数量：每次处理一个batch，故直接添加l.batch
        *net.seen += net.batch;
        // 标记处于训练阶段
        net.train = 1;
        forward_network(net);
        backward_network(net);
        float error = *net.cost;
        if(((*net.seen)/net.batch)%net.subdivisions == 0) update_network(net);
        return error;
    }

#### 3. network.c/forward\_network() ####

/** 前向计算网络net每一层的输出. * @param net 构建好的整个网络模型 * @details 遍历net的每一层网络，从第0层到最后一层，逐层计算每层的输出 */
    void forward_network(network net)
    {
        int i;
        /// 遍历所有层，从第一层到最后一层，逐层进行前向传播（网络总共有net.n层）
        for(i = 0; i < net.n; ++i){
            /// 置网络当前活跃层为当前层，即第i层
            net.index = i;
            /// 获取当前层
            layer l = net.layers[i];
            /// 如果当前层的l.delta已经动态分配了内存，则调用fill_cpu()函数，将其所有元素的值初始化为0
            if(l.delta){
                /// 第一个参数为l.delta的元素个数，第二个参数为初始化值，为0
                fill_cpu(l.outputs * l.batch, 0, l.delta, 1);
            }
    
            /// 前向传播（前向推理）：完成l层的前向推理
            l.forward(l, net);
    
            /// 完成某一层的推理时，置网络的输入为当前层的输出（这将成为下一层网络的输入），要注意的是，此处是直接更改指针变量net.input本身的值，
            /// 也就是此处是通过改变指针net.input所指的地址来改变其中所存内容的值，并不是直接改变其所指的内容而指针所指的地址没变，
            /// 所以在退出forward_network()函数后，其对net.input的改变都将失效，net.input将回到进入forward_network()之前时的值。
            net.input = l.output;
            if(l.truth) {
                net.truth = l.output;
            }
        }
        calc_network_cost(net);
    }

void calc_network_cost(network net)
    {
        int i;
        float sum = 0;
        int count = 0;
        for(i = 0; i < net.n; ++i){
            if(net.layers[i].cost){
                sum += net.layers[i].cost[0];
                ++count;
            }
        }
        *net.cost = sum/count;
    }

#### 4. network.c/backward\_network() ####

/*
    ** 反向计算网络net每一层的敏感度图，并进而计算每一层的权重、偏置更新值，最后完成每一层权重与偏置更新
    ** 流程：遍历net的每一层网络，从最后一层到第一层（此处所指的第一层不是指输入层，而是与输入层直接相连的第一层隐含层），反向传播
    */
    void backward_network(network net)
    {
        int i;
        // 在进行反向之前，先保存一下原先的net，下面会用到orig的input
        network orig = net;
        for(i = net.n-1; i >= 0; --i){
            layer l = net.layers[i];
            if(l.stopbackward) break;
            // i = 0时，也即已经到了网络的第1层（或者说第0层，看个人习惯了～）了，就是直接与输入层相连的第一层隐含层（注意不是输入层，我理解的输入层就是指输入的图像数据，
            // 严格来说，输入层不算一层网络，因为输入层没有训练参数，也没有激活函数），这个时候，不需要else中的赋值，1）对于第1层来说，其前面已经没有网络层了（输入层不算），
            // 因此没有必要再计算前一层的参数，故没有必要在获取上一层；2）第一层的输入就是图像输入，也即整个net最原始的输入，在开始进行反向传播之前，已经用orig变量保存了
            // 最为原始的net，所以net.input就是第一层的输入，不需要通过net.input=prev.output获取上一层的输出作为当前层的输入；3）同1），第一层之前已经没有层了，
            // 也就不需要计算上一层的delta，即不需要再将net.delta链接到prev.delta，此时进入到l.backward()中后，net.delta就是NULL（可以参看network.h中关于delta
            // 的注释），也就不会再计算上一层的敏感度了（比如卷积神经网络中的backward_convolutional_layer()函数）
            if(i == 0){
                net = orig;
            }else{
                // 获取上一层
                layer prev = net.layers[i-1];
                // 上一层的输出作为当前层的输入（下面l.backward()会用到，具体是在计算当前层权重更新值时要用到）
                net.input = prev.output;
                // 上一层的敏感度图（l.backward()会同时计算上一层的敏感度图）
                net.delta = prev.delta;
            }
            // 置网络当前活跃层为当前层，即第i层
            net.index = i;
            // 反向计算第i层的敏感度图、权重及偏置更新值，并更新权重、偏置（同时会计算上一层的敏感度图，
            // 存储在net.delta中，但是还差一个环节：乘上上一层输出对加权输入的导数，也即上一层激活函数对加权输入的导数）
            l.backward(l, net);
        }
    }

#### 5. network.c/update\_network() ####

void update_network(network net)
    {
        int i;
        int update_batch = net.batch*net.subdivisions;
        float rate = get_current_rate(net);
        for(i = 0; i < net.n; ++i){
            layer l = net.layers[i];
            if(l.update){
                l.update(l, update_batch, rate*l.learning_rate_scale, net.momentum, net.decay);
            }
        }
    }