本系列為darknet源碼解析，本次解析src/reorg_layer.h 與 src/reorg_layer.c 兩個。在yolo v2中reorg_layer主要将第25層的輸出26*26*512的特征圖reshape成13*13*2048。
網上也有一些reorg層的解析，解釋如下，但是發現我在閱讀完reorg_layer的前向傳播後，發現下面解析有問題。與代碼實際不符；
下面我們用圖去解析reorg層26*26 是如何reshape 成13*13.
下面是reorg層的第一個通道，第一組512個13*13的reshape操作如下：【灰色填充部分】每一行采樣13個，後面表示為13*13特征圖第幾号。這樣就可以reshape成13*13呢。輸入特征圖一般都是按行存儲，用一位數組儲存；
下圖是reorg輸入層的第2個通道，
是不是發現了規律，這樣一直采樣到最後一個通道，但是這樣隻擷取了512 個 13*13，還有3個512的13*13如何采樣呢？？？在26*26的特征圖中，我們可以發現，如下圖所示，隻采樣了[0,0],[1, 0]，其餘6個點并沒有使用。那麼接下來的3*512的13*13采樣就與其他6個點有關。
第二組的512個13*13的reshape操作如下：【橘黃色部分】
。。。。。直到最後一個通道；
第三組的512個13*13的reshape操作如下：【藍色部分】
。。。。直到最後一個通道；
第四組的512個13*13的reshape操作，就是上圖的【白色部分】
。。。。直到最後一個通道；
reorg_layer.h的定義如下：
#ifndef REORG_LAYER_H
#define REORG_LAYER_H
#include "image.h"
#include "cuda.h"
#include "layer.h"
#include "network.h"
// 構造yolo v2 reorg層
layer make_reorg_layer(int batch, int w, int h, int c, int stride, int reverse, int flatten, int extra);
void resize_reorg_layer(layer *l, int w, int h);
// yolo v2 reorg層的前向反向傳播
void forward_reorg_layer(const layer l, network net);
void backward_reorg_layer(const layer l, network net);
#ifdef GPU
void forward_reorg_layer_gpu(layer l, network net);
void backward_reorg_layer_gpu(layer l, network net);
#endif
#endif
reorg_layer.c 的詳細解釋如下：
#include "reorg_layer.h"
#include "cuda.h"
#include "blas.h"
#include <stdio.h>
/**
* 建構reorg層
* reorg層在yolov2的第26層，第25層的輸出26 × 26 × 512，reshape後為 13 × 13 × 2048;
* @param batch 一個batch中包含圖檔的張數
* @param w 輸入圖檔的寬度
* @param h 輸入圖檔的高度
* @param c 輸入圖檔的通道數
* @param stride 步幅，在yolo v2中為2
* @param reverse 在yolo v2中為0
* @param flatten 在yolo v2中為0
* @param extra 在yolo v2中為0
* @return
*/
layer make_reorg_layer(int batch, int w, int h, int c, int stride, int reverse, int flatten, int extra)
{
layer l = {0};
l.type = REORG; // 層類别
l.batch = batch; // 一個batch中圖檔的張數
l.stride = stride; // 圖像卷積步幅
l.extra = extra;
l.h = h; // 輸入圖檔的高度
l.w = w; // 輸入圖檔的寬度
l.c = c; // 輸入圖檔的通道數
l.flatten = flatten;
if(reverse){
l.out_w = w*stride;
l.out_h = h*stride;
l.out_c = c/(stride*stride);
}else{ // 計算輸出特征圖的高度,寬度,通道數
l.out_w = w/stride; // yolov2 在這裡 w為26， stride 為2, out_w 為 13
l.out_h = h/stride; // yolov2 在這裡 h為26， stride 為2, out_h 為 13
l.out_c = c*(stride*stride); // // yolov2 在這裡 c為512， stride 為2, out_c 為 2048
}
l.reverse = reverse; // yolo v2中 reverse為0
l.outputs = l.out_h * l.out_w * l.out_c; // 對應輸入圖像輸出圖像元素的個數
l.inputs = h*w*c; // reorg層一張輸入圖檔的元素個數
if(l.extra){ // yolo v2中 extra為0
l.out_w = l.out_h = l.out_c = 0;
l.outputs = l.inputs + l.extra;
}
if(extra){
fprintf(stderr, "reorg %4d -> %4d\n", l.inputs, l.outputs);
} else {
fprintf(stderr, "reorg /%2d %4d x%4d x%4d -> %4d x%4d x%4d\n", stride, w, h, c, l.out_w, l.out_h, l.out_c);
}
int output_size = l.outputs * batch;
l.output = calloc(output_size, sizeof(float)); // reorg所有輸出（包含整個batch）
l.delta = calloc(output_size, sizeof(float)); // reorg層誤差項（包含整個batch）
l.forward = forward_reorg_layer; // reorg層前向傳播
l.backward = backward_reorg_layer; // reorg層反向傳播
#ifdef GPU
l.forward_gpu = forward_reorg_layer_gpu;
l.backward_gpu = backward_reorg_layer_gpu;
l.output_gpu = cuda_make_array(l.output, output_size);
l.delta_gpu = cuda_make_array(l.delta, output_size);
#endif
return l;
}
void resize_reorg_layer(layer *l, int w, int h)
{
int stride = l->stride;
int c = l->c;
l->h = h;
l->w = w;
if(l->reverse){
l->out_w = w*stride;
l->out_h = h*stride;
l->out_c = c/(stride*stride);
}else{
l->out_w = w/stride;
l->out_h = h/stride;
l->out_c = c*(stride*stride);
}
l->outputs = l->out_h * l->out_w * l->out_c;
l->inputs = l->outputs;
int output_size = l->outputs * l->batch;
l->output = realloc(l->output, output_size * sizeof(float));
l->delta = realloc(l->delta, output_size * sizeof(float));
#ifdef GPU
cuda_free(l->output_gpu);
cuda_free(l->delta_gpu);
l->output_gpu = cuda_make_array(l->output, output_size);
l->delta_gpu = cuda_make_array(l->delta, output_size);
#endif
}
// reorg_cpu(net.input, l.w, l.h, l.c, l.batch, l.stride, 0, l.output);
void reorg_cpu(float *x, int w, int h, int c, int batch, int stride, int forward, float *out)
{
int b,i,j,k;
int out_c = c/(stride*stride); // 512/4 = 128
for(b = 0; b < batch; ++b){
for(k = 0; k < c; ++k){
for(j = 0; j < h; ++j){
for(i = 0; i < w; ++i){
int in_index = i + w*(j + h*(k + c*b)); // 采樣儲存在13×13*512的位置的index
int c2 = k % out_c; // 第幾個512的reshape，[0,1,2,3]
int offset = k / out_c; // 偏移量,第幾中reshape的第幾個
int w2 = i*stride + offset % stride;
int h2 = j*stride + offset / stride;
int out_index = w2 + w*stride*(h2 + h*stride*(c2 + out_c*b)); // 擷取在26*26*512采樣位置的index
if(forward) out[out_index] = x[in_index]; // 梯度反傳
else out[in_index] = x[out_index]; // 前向傳播
}
}
}
}
}
/**
* reorg 層前向傳播
* @param l 目前reorg層
* @param net 整個網絡
*/
void forward_reorg_layer(const layer l, network net)
{
int i;
if(l.flatten){ // yolov2 此處不執行
memcpy(l.output, net.input, l.outputs*l.batch*sizeof(float));
if(l.reverse){
flatten(l.output, l.w*l.h, l.c, l.batch, 0);
}else{
flatten(l.output, l.w*l.h, l.c, l.batch, 1);
}
} else if (l.extra) { // yolov2 此處不執行
for(i = 0; i < l.batch; ++i){
copy_cpu(l.inputs, net.input + i*l.inputs, 1, l.output + i*l.outputs, 1);
}
} else if (l.reverse){ // yolov2 此處不執行
reorg_cpu(net.input, l.w, l.h, l.c, l.batch, l.stride, 1, l.output);
} else {
reorg_cpu(net.input, l.w, l.h, l.c, l.batch, l.stride, 0, l.output);
}
}
/**
* yolo v2 reorg層反向傳播函數
* @param l 目前reorg層
* @param net 整個網絡
*/
void backward_reorg_layer(const layer l, network net)
{
int i;
if(l.flatten){ // yolov2 此處不執行
memcpy(net.delta, l.delta, l.outputs*l.batch*sizeof(float));
if(l.reverse){
flatten(net.delta, l.w*l.h, l.c, l.batch, 1);
}else{
flatten(net.delta, l.w*l.h, l.c, l.batch, 0);
}
} else if(l.reverse){ // yolov2 此處不執行
reorg_cpu(l.delta, l.w, l.h, l.c, l.batch, l.stride, 0, net.delta);
} else if (l.extra) { // yolov2 此處不執行
for(i = 0; i < l.batch; ++i){
copy_cpu(l.inputs, l.delta + i*l.outputs, 1, net.delta + i*l.inputs, 1);
}
}else{ // 進行誤差反向傳播
reorg_cpu(l.delta, l.w, l.h, l.c, l.batch, l.stride, 1, net.delta);
}
}
#ifdef GPU
void forward_reorg_layer_gpu(layer l, network net)
{
int i;
if(l.flatten){
if(l.reverse){
flatten_gpu(net.input_gpu, l.w*l.h, l.c, l.batch, 0, l.output_gpu);
}else{
flatten_gpu(net.input_gpu, l.w*l.h, l.c, l.batch, 1, l.output_gpu);
}
} else if (l.extra) {
for(i = 0; i < l.batch; ++i){
copy_gpu(l.inputs, net.input_gpu + i*l.inputs, 1, l.output_gpu + i*l.outputs, 1);
}
} else if (l.reverse) {
reorg_gpu(net.input_gpu, l.w, l.h, l.c, l.batch, l.stride, 1, l.output_gpu);
}else {
reorg_gpu(net.input_gpu, l.w, l.h, l.c, l.batch, l.stride, 0, l.output_gpu);
}
}
void backward_reorg_layer_gpu(layer l, network net)
{
if(l.flatten){
if(l.reverse){
flatten_gpu(l.delta_gpu, l.w*l.h, l.c, l.batch, 1, net.delta_gpu);
}else{
flatten_gpu(l.delta_gpu, l.w*l.h, l.c, l.batch, 0, net.delta_gpu);
}
} else if (l.extra) {
int i;
for(i = 0; i < l.batch; ++i){
copy_gpu(l.inputs, l.delta_gpu + i*l.outputs, 1, net.delta_gpu + i*l.inputs, 1);
}
} else if(l.reverse){
reorg_gpu(l.delta_gpu, l.w, l.h, l.c, l.batch, l.stride, 0, net.delta_gpu);
} else {
reorg_gpu(l.delta_gpu, l.w, l.h, l.c, l.batch, l.stride, 1, net.delta_gpu);
}
}
#endif
完，