【darknet源码解析-23】route_layer.h 和 route_layer.c 解析

本系列为darknet源码解析，本次解析src/route_layer.h 与 src/route_layer.c 两个。在yolo v2中reorg_layer主要将几个输入层拼接在一起，例如：输入层1: 26*26*256   输入层2： 26*26*128， 则route输出为：26*26*(256+128)；

route_layer.h 的定义如下：

#ifndef ROUTE_LAYER_H
#define ROUTE_LAYER_H
#include "network.h"
#include "layer.h"

typedef layer route_layer;

// 构建yolo v2 route层
route_layer make_route_layer(int batch, int n, int *input_layers, int *input_size);

// yolo v2 route层的前向，反向传播
void forward_route_layer(const route_layer l, network net);
void backward_route_layer(const route_layer l, network net);
void resize_route_layer(route_layer *l, network *net);

#ifdef GPU
void forward_route_layer_gpu(const route_layer l, network net);
void backward_route_layer_gpu(const route_layer l, network net);
#endif

#endif

route_layer.c 的详细解释如下：

#include "route_layer.h"
#include "cuda.h"
#include "blas.h"

#include <stdio.h>

/**
 * 构建route层
 * 说明： route层主要是把对应层连接在一起，在darknet网络结构中，要求输入层对应的width，height必须相等，
 * 如果不相等，则把route层的输出w, h, c都设置为0.
 * 例子：输入层1: 26*26*256   输入层2： 26*26*128， 则route输出为：26*26*(256+128)
 * route层具有可以具有一个或两个值的属性层。当属性只有一个值时，它会输出该值索引的网络层的特征图。
 * @param batch 一个batch中包含图片的张数
 * @param n route层输入层的个数
 * @param input_layers 输入层的层号
 * @param input_sizes 输入层的大小
 * @return
 */
route_layer make_route_layer(int batch, int n, int *input_layers, int *input_sizes)
{
    fprintf(stderr,"route ");
    route_layer l = {0};
    l.type = ROUTE; // 层类别
    l.batch = batch; // 一个batch中包含图片的张数
    l.n = n; // route输入层的个数
    l.input_layers = input_layers; // 输入层的层号
    l.input_sizes = input_sizes; // 输入层的大小
    int i;
    int outputs = 0;
    for(i = 0; i < n; ++i){
        fprintf(stderr," %d", input_layers[i]);
        outputs += input_sizes[i]; // 计算route层输入输出大小，route层不改变输入输出元素
    }
    fprintf(stderr, "\n");
    l.outputs = outputs; // route层一张输入图片的元素个数
    l.inputs = outputs; // route层对应一张输入图片的输出元素个数
    l.delta =  calloc(outputs*batch, sizeof(float)); // route层的误差项（包含整个batch的）
    l.output = calloc(outputs*batch, sizeof(float)); // route层的所有输出（包含整个batch的）

    // route层的前向,反向
    l.forward = forward_route_layer;
    l.backward = backward_route_layer;
    #ifdef GPU
    l.forward_gpu = forward_route_layer_gpu;
    l.backward_gpu = backward_route_layer_gpu;

    l.delta_gpu =  cuda_make_array(l.delta, outputs*batch);
    l.output_gpu = cuda_make_array(l.output, outputs*batch);
    #endif
    return l;
}

void resize_route_layer(route_layer *l, network *net)
{
    int i;
    layer first = net->layers[l->input_layers[0]];
    l->out_w = first.out_w;
    l->out_h = first.out_h;
    l->out_c = first.out_c;
    l->outputs = first.outputs;
    l->input_sizes[0] = first.outputs;
    for(i = 1; i < l->n; ++i){
        int index = l->input_layers[i];
        layer next = net->layers[index];
        l->outputs += next.outputs;
        l->input_sizes[i] = next.outputs;
        if(next.out_w == first.out_w && next.out_h == first.out_h){
            l->out_c += next.out_c;
        }else{
            printf("%d %d, %d %d\n", next.out_w, next.out_h, first.out_w, first.out_h);
            l->out_h = l->out_w = l->out_c = 0;
        }
    }
    l->inputs = l->outputs;
    l->delta =  realloc(l->delta, l->outputs*l->batch*sizeof(float));
    l->output = realloc(l->output, l->outputs*l->batch*sizeof(float));

#ifdef GPU
    cuda_free(l->output_gpu);
    cuda_free(l->delta_gpu);
    l->output_gpu  = cuda_make_array(l->output, l->outputs*l->batch);
    l->delta_gpu   = cuda_make_array(l->delta,  l->outputs*l->batch);
#endif
    
}

/**
 * route层前向传播函数
 * @param l 当前route层
 * @param net 整个网络
 */
void forward_route_layer(const route_layer l, network net)
{
    int i, j;
    int offset = 0;
    for(i = 0; i < l.n; ++i){ // 遍历每个route层的输入层
        int index = l.input_layers[i]; // 获得输入层的编号index
        float *input = net.layers[index].output; //根据index获取该层的输出，作为route的输入
        int input_size = l.input_sizes[i]; // 元素个数
        for(j = 0; j < l.batch; ++j){ // 拼凑batch张特征图
            // l.output + offset + j*l.outputs = input + j*input_size
            copy_cpu(input_size, input + j*input_size, 1, l.output + offset + j*l.outputs, 1);
        }
        offset += input_size; // 计算位置偏移量
    }
}

/**
 * route层反向传播函数
 * @param l 当前route层
 * @param net 整个网络
 */
void backward_route_layer(const route_layer l, network net)
{
    int i, j;
    int offset = 0;
    for(i = 0; i < l.n; ++i){ // 遍历每个route层的输入层
        int index = l.input_layers[i]; // 获得输入层的编号index
        float *delta = net.layers[index].delta; //根据index获取该层的误差项存储位置，作为route的反向传播的输出
        int input_size = l.input_sizes[i]; // 元素个数
        for(j = 0; j < l.batch; ++j){
            // delta + j*input_size += l.delta + offset + j*l.outputs
            axpy_cpu(input_size, 1, l.delta + offset + j*l.outputs, 1, delta + j*input_size, 1);
        }
        offset += input_size; // 计算位置偏移量
    }
}

#ifdef GPU
void forward_route_layer_gpu(const route_layer l, network net)
{
    int i, j;
    int offset = 0;
    for(i = 0; i < l.n; ++i){
        int index = l.input_layers[i];
        float *input = net.layers[index].output_gpu;
        int input_size = l.input_sizes[i];
        for(j = 0; j < l.batch; ++j){
            copy_gpu(input_size, input + j*input_size, 1, l.output_gpu + offset + j*l.outputs, 1);
        }
        offset += input_size;
    }
}

void backward_route_layer_gpu(const route_layer l, network net)
{
    int i, j;
    int offset = 0;
    for(i = 0; i < l.n; ++i){
        int index = l.input_layers[i];
        float *delta = net.layers[index].delta_gpu;
        int input_size = l.input_sizes[i];
        for(j = 0; j < l.batch; ++j){
            axpy_gpu(input_size, 1, l.delta_gpu + offset + j*l.outputs, 1, delta + j*input_size, 1);
        }
        offset += input_size;
    }
}
#endif

完，