【darknet源碼解析-08】cost_layer.h 和 cost_layer.c 解析

本系列爲darknet源碼解析，本次解析src/cost_layer.h 與 src/cost_layer.c 兩個。在本文中，cost主要完成多種損失函數的前向計算以及損失損失函數反向傳播。

COST_TYPE定義在include/darknet.h中,是枚舉類型. 可以發現darknet提供了六種損失函數.

typedef enum{
    SSE, MASKED, L1, SEG, SMOOTH,WGAN
} COST_TYPE;

cost_layer.h 的解析如下: 

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

typedef layer cost_layer;

// 獲取定義的枚舉類型的損失函數類別
COST_TYPE get_cost_type(char *s);

// 獲取損失函數對應的字符串描述
char *get_cost_string(COST_TYPE a);

// 構建損失函數層
cost_layer make_cost_layer(int batch, int inputs, COST_TYPE type, float scale);

// 損失函數層的前向傳播計算
void forward_cost_layer(const cost_layer l, network net);

// 損失韓式層的反向傳播計算
void backward_cost_layer(const cost_layer l, network net);
void resize_cost_layer(cost_layer *l, int inputs);

#ifdef GPU
void forward_cost_layer_gpu(cost_layer l, network net);
void backward_cost_layer_gpu(const cost_layer l, network net);
#endif

#endif

cost_layer.c 的解析如下:

#include "cost_layer.h"
#include "utils.h"
#include "cuda.h"
#include "blas.h"
#include <math.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>

/**
 * 根據輸入的損失函數名稱,返回定義的枚舉類型的損失函數類別
 * @param s 損失函數的名稱
 * @return 損失函數類別: 枚舉類型
 * 說明: 如果不匹配,默認採用 SSE
 */
COST_TYPE get_cost_type(char *s)
{
    if (strcmp(s, "seg")==0) return SEG;
    if (strcmp(s, "sse")==0) return SSE;
    if (strcmp(s, "masked")==0) return MASKED;
    if (strcmp(s, "smooth")==0) return SMOOTH;
    if (strcmp(s, "L1")==0) return L1;
    if (strcmp(s, "wgan")==0) return WGAN;
    fprintf(stderr, "Couldn't find cost type %s, going with SSE\n", s);
    return SSE;
}

/**
 * 獲得定義的枚舉類型的損失函數字符串描述
 * @param a 損失函數類別: 枚舉類型
 * @return 返回損失函數的字符串描述
 * 說明: 如果不匹配, 默認採用SSE
 */
char *get_cost_string(COST_TYPE a)
{
    switch(a){
        case SEG:
            return "seg";
        case SSE:
            return "sse";
        case MASKED:
            return "masked";
        case SMOOTH:
            return "smooth";
        case L1:
            return "L1";
        case WGAN:
            return "wgan";
    }
    return "sse";
}

/**
 * 構建損失函數層
 * @param batch 該層輸入中一個batch所含有圖片的張數,等於net.batch
 * @param inputs 損失函數層每張輸入圖片的元素個數
 * @param cost_type 損失函數類型
 * @param scale
 * @return 損失函數層 l
 */
cost_layer make_cost_layer(int batch, int inputs, COST_TYPE cost_type, float scale)
{
    fprintf(stderr, "cost                                           %4d\n",  inputs);
    cost_layer l = {0};
    l.type = COST;

    l.scale = scale;
    l.batch = batch; //一個batch中圖片張數
    l.inputs = inputs; // 損失函數層一張輸入圖片的元素個數
    l.outputs = inputs; // 損失函數層對應一張輸入圖片的輸出元素個數
    l.cost_type = cost_type; // 損失函數類型
    l.delta = calloc(inputs*batch, sizeof(float)); //損失函數層的誤差項(包含整個batch的)
    l.output = calloc(inputs*batch, sizeof(float)); //損失函數層所有輸出 (包含整個batch的)
    l.cost = calloc(1, sizeof(float)); // 損失函數值

    // 損失函數層前向, 反向
    l.forward = forward_cost_layer;
    l.backward = backward_cost_layer;
    #ifdef GPU
    l.forward_gpu = forward_cost_layer_gpu;
    l.backward_gpu = backward_cost_layer_gpu;

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

void resize_cost_layer(cost_layer *l, int inputs)
{
    l->inputs = inputs;
    l->outputs = inputs;
    l->delta = realloc(l->delta, inputs*l->batch*sizeof(float));
    l->output = realloc(l->output, inputs*l->batch*sizeof(float));
#ifdef GPU
    cuda_free(l->delta_gpu);
    cuda_free(l->output_gpu);
    l->delta_gpu = cuda_make_array(l->delta, inputs*l->batch);
    l->output_gpu = cuda_make_array(l->output, inputs*l->batch);
#endif
}

// L1計算
void l1_cpu(int n, float *pred, float *truth, float *delta, float *error) {
    int i;
    for(i = 0; i < n; i ++) {
        float diff = truth[i] - pred[i];
        error[i] = fabs(diff);
        delta[i] = diff > 0 ? 1 : -1;
    }
}

// SSE, 即L2, 誤差平方和,可以發現這裏並沒有乘以1/2. 一般往 
void l2_cpu(int n, float *pred, float *truth, float *delta, float *error) {
    int i;
    for(i = 0; i < n; i ++) {
        float diff = truth[i] - pred[i];
        error[i] = diff * diff;
        delta[i] = diff;
    }
}


/**
 * 損失函數層的前向傳播函數
 * @param l 當前損失函數層
 * @param net 整個網絡
 */
void forward_cost_layer(cost_layer l, network net)
{
    if (!net.truth) return; //如果
    if(l.cost_type == MASKED){ // MASKED只發現在darknet9000.cfg中使用
        int i;
        for(i = 0; i < l.batch*l.inputs; ++i){
            if(net.truth[i] == SECRET_NUM) net.input[i] = SECRET_NUM;
        }
    }
    if(l.cost_type == SMOOTH){ // 如果損失函數是 smooth l1
        smooth_l1_cpu(l.batch*l.inputs, net.input, net.truth, l.delta, l.output);
    }else if(l.cost_type == L1){ // 如果損失函數是 l1
        l1_cpu(l.batch*l.inputs, net.input, net.truth, l.delta, l.output);
    } else { // 否則
        l2_cpu(l.batch*l.inputs, net.input, net.truth, l.delta, l.output);
    }
    // 求loss總和
    l.cost[0] = sum_array(l.output, l.batch*l.inputs);
}


// Y += alpha * X
void axpy_cpu(int N, float ALPHA, float *X, int INCX, float *Y, int INCY)
{
    int i;
    for(i = 0; i < N; ++i) Y[i*INCY] += ALPHA*X[i*INCX];
}
/**
 * 損失函數層的反向傳播函數
 * @param l 當前損失函數層
 * @param net 整個網絡
 */
void backward_cost_layer(const cost_layer l, network net)
{
    // net.data += l.scale * l.delta
    axpy_cpu(l.batch*l.inputs, l.scale, l.delta, 1, net.delta, 1);
}

#ifdef GPU

void pull_cost_layer(cost_layer l)
{
    cuda_pull_array(l.delta_gpu, l.delta, l.batch*l.inputs);
}

void push_cost_layer(cost_layer l)
{
    cuda_push_array(l.delta_gpu, l.delta, l.batch*l.inputs);
}

int float_abs_compare (const void * a, const void * b)
{
    float fa = *(const float*) a;
    if(fa < 0) fa = -fa;
    float fb = *(const float*) b;
    if(fb < 0) fb = -fb;
    return (fa > fb) - (fa < fb);
}

void forward_cost_layer_gpu(cost_layer l, network net)
{
    if (!net.truth) return;
    if(l.smooth){
        scal_gpu(l.batch*l.inputs, (1-l.smooth), net.truth_gpu, 1);
        add_gpu(l.batch*l.inputs, l.smooth * 1./l.inputs, net.truth_gpu, 1);
    }

    if(l.cost_type == SMOOTH){
        smooth_l1_gpu(l.batch*l.inputs, net.input_gpu, net.truth_gpu, l.delta_gpu, l.output_gpu);
    } else if (l.cost_type == L1){
        l1_gpu(l.batch*l.inputs, net.input_gpu, net.truth_gpu, l.delta_gpu, l.output_gpu);
    } else if (l.cost_type == WGAN){
        wgan_gpu(l.batch*l.inputs, net.input_gpu, net.truth_gpu, l.delta_gpu, l.output_gpu);
    } else {
        l2_gpu(l.batch*l.inputs, net.input_gpu, net.truth_gpu, l.delta_gpu, l.output_gpu);
    }

    if (l.cost_type == SEG && l.noobject_scale != 1) {
        scale_mask_gpu(l.batch*l.inputs, l.delta_gpu, 0, net.truth_gpu, l.noobject_scale);
        scale_mask_gpu(l.batch*l.inputs, l.output_gpu, 0, net.truth_gpu, l.noobject_scale);
    }
    if (l.cost_type == MASKED) {
        mask_gpu(l.batch*l.inputs, net.delta_gpu, SECRET_NUM, net.truth_gpu, 0);
    }

    if(l.ratio){
        cuda_pull_array(l.delta_gpu, l.delta, l.batch*l.inputs);
        qsort(l.delta, l.batch*l.inputs, sizeof(float), float_abs_compare);
        int n = (1-l.ratio) * l.batch*l.inputs;
        float thresh = l.delta[n];
        thresh = 0;
        printf("%f\n", thresh);
        supp_gpu(l.batch*l.inputs, thresh, l.delta_gpu, 1);
    }

    if(l.thresh){
        supp_gpu(l.batch*l.inputs, l.thresh*1./l.inputs, l.delta_gpu, 1);
    }

    cuda_pull_array(l.output_gpu, l.output, l.batch*l.inputs);
    l.cost[0] = sum_array(l.output, l.batch*l.inputs);
}

void backward_cost_layer_gpu(const cost_layer l, network net)
{
    axpy_gpu(l.batch*l.inputs, l.scale, l.delta_gpu, 1, net.delta_gpu, 1);
}
#endif

cost_layer.c 源碼分析如下:

#include "cost_layer.h"
#include "utils.h"
#include "cuda.h"
#include "blas.h"
#include <math.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>

/**
 * 根據輸入的損失函數名稱,返回定義的枚舉類型的損失函數類別
 * @param s 損失函數的名稱
 * @return 損失函數類別: 枚舉類型
 * 說明: 如果不匹配,默認採用 SSE
 */
COST_TYPE get_cost_type(char *s)
{
    if (strcmp(s, "seg")==0) return SEG;
    if (strcmp(s, "sse")==0) return SSE;
    if (strcmp(s, "masked")==0) return MASKED;
    if (strcmp(s, "smooth")==0) return SMOOTH;
    if (strcmp(s, "L1")==0) return L1;
    if (strcmp(s, "wgan")==0) return WGAN;
    fprintf(stderr, "Couldn't find cost type %s, going with SSE\n", s);
    return SSE;
}

/**
 * 獲得定義的枚舉類型的損失函數字符串描述
 * @param a 損失函數類別: 枚舉類型
 * @return 返回損失函數的字符串描述
 * 說明: 如果不匹配, 默認採用SSE
 */
char *get_cost_string(COST_TYPE a)
{
    switch(a){
        case SEG:
            return "seg";
        case SSE:
            return "sse";
        case MASKED:
            return "masked";
        case SMOOTH:
            return "smooth";
        case L1:
            return "L1";
        case WGAN: //沒有CPU版本
            return "wgan";
    }
    return "sse";
}

/**
 * 構建損失函數層
 * @param batch 該層輸入中一個batch所含有圖片的張數,等於net.batch
 * @param inputs 損失函數層每張輸入圖片的元素個數
 * @param cost_type 損失函數類型
 * @param scale
 * @return 損失函數層 l
 */
cost_layer make_cost_layer(int batch, int inputs, COST_TYPE cost_type, float scale)
{
    fprintf(stderr, "cost                                           %4d\n",  inputs);
    cost_layer l = {0};
    l.type = COST;

    l.scale = scale; // 用於誤差反傳的時候
    l.batch = batch; // 一個batch中圖片張數
    l.inputs = inputs; // 損失函數層一張輸入圖片的元素個數
    l.outputs = inputs; // 損失函數層對應一張輸入圖片的輸出元素個數
    l.cost_type = cost_type; // 損失函數類型
    l.delta = calloc(inputs*batch, sizeof(float)); //損失函數層的誤差項(包含整個batch的)
    l.output = calloc(inputs*batch, sizeof(float)); //損失函數層所有輸出 (包含整個batch的)
    l.cost = calloc(1, sizeof(float)); // 損失函數值

    // 損失函數層前向, 反向
    l.forward = forward_cost_layer;
    l.backward = backward_cost_layer;
    #ifdef GPU
    l.forward_gpu = forward_cost_layer_gpu;
    l.backward_gpu = backward_cost_layer_gpu;

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

void resize_cost_layer(cost_layer *l, int inputs)
{
    l->inputs = inputs;
    l->outputs = inputs;
    l->delta = realloc(l->delta, inputs*l->batch*sizeof(float));
    l->output = realloc(l->output, inputs*l->batch*sizeof(float));
#ifdef GPU
    cuda_free(l->delta_gpu);
    cuda_free(l->output_gpu);
    l->delta_gpu = cuda_make_array(l->delta, inputs*l->batch);
    l->output_gpu = cuda_make_array(l->output, inputs*l->batch);
#endif
}

// L1計算
// L1(x) = |x|
// dL1(x) = 1 if x > 0
//        = -1 otherwise
// L1對x的導數爲常數.這就導致訓練後期,預測值與GT的差異很小時,L1損失對預測值的導數的絕對值仍然爲1, 
// 而learning rate如果不變,損失函數將在穩定值附近波動,難以繼續收斂以達到更高精度.
void l1_cpu(int n, float *pred, float *truth, float *delta, float *error) {
    int i;
    for(i = 0; i < n; i ++) {
        float diff = truth[i] - pred[i];
        error[i] = fabs(diff);
        delta[i] = diff > 0 ? 1 : -1;
    }
}

// SSE, 即L2, 誤差平方和,可以發現這裏並沒有乘以1/2. 一般往
//  L2(x) = x**2
// dL2(x) /dx = 2x 當x增大時,L2損失對x的導數也增大,這就導致訓練初期,預測值與GT差異過大,損失對預測值的梯度十分大,訓練不穩定
void l2_cpu(int n, float *pred, float *truth, float *delta, float *error) {
    int i;
    for(i = 0; i < n; i ++) {
        float diff = truth[i] - pred[i];
        error[i] = diff * diff;
        delta[i] = diff;
    }
}

// smooth_l1_loss(x) = 0.5* x**2 / beta |x| < 1,
//                   = |x| - 0.5 * beta otherwise. 
// d(smooth_l1_loss(x))/d(x) = x if |x| < 1
//                           = +/- 1 otherwise.
// smooth_l1 在x較小的時候,對x的梯度也會變小,而x很大時,對x的梯度的絕對值達到1,
// 也不會太大以至於破壞網絡, smooth_l1 完美的避開了L1和L2損失函數的缺陷.
// 主流smooth方式,會設定beta = 9. 這裏不做過多探討.
void smooth_l1_cpu(int n, float *pred, float *truth, float *delta, float *error)
{
    int i;
    for(i = 0; i < n; ++i){
        float diff = truth[i] - pred[i];
        float abs_val = fabs(diff);
        if(abs_val < 1) {
            error[i] = diff * diff;
            delta[i] = diff;
        }
        else {
            error[i] = 2*abs_val - 1;
            delta[i] = (diff < 0) ? 1 : -1;
        }
    }
}


/**
 * 損失函數層的前向傳播函數
 * @param l 當前損失函數層
 * @param net 整個網絡
 */
void forward_cost_layer(cost_layer l, network net)
{
    if (!net.truth) return; //如果
    if(l.cost_type == MASKED){ // MASKED只發現在darknet9000.cfg中使用
        int i;  // #define SECRET_NUM -1234 定義在include/darknet.h中
        for(i = 0; i < l.batch*l.inputs; ++i){
            if(net.truth[i] == SECRET_NUM) net.input[i] = SECRET_NUM;
        }
    }
    if(l.cost_type == SMOOTH){ // 如果損失函數是 smooth l1
        smooth_l1_cpu(l.batch*l.inputs, net.input, net.truth, l.delta, l.output);
    }else if(l.cost_type == L1){ // 如果損失函數是 l1
        l1_cpu(l.batch*l.inputs, net.input, net.truth, l.delta, l.output);
    } else { // 否則
        l2_cpu(l.batch*l.inputs, net.input, net.truth, l.delta, l.output);
    }
    // 求loss總和
    l.cost[0] = sum_array(l.output, l.batch*l.inputs);
}


// Y += alpha * X
void axpy_cpu(int N, float ALPHA, float *X, int INCX, float *Y, int INCY)
{
    int i;
    for(i = 0; i < N; ++i) Y[i*INCY] += ALPHA*X[i*INCX];
}
/**
 * 損失函數層的反向傳播函數
 * @param l 當前損失函數層
 * @param net 整個網絡
 */
void backward_cost_layer(const cost_layer l, network net)
{
    // net.data += l.scale * l.delta
    axpy_cpu(l.batch*l.inputs, l.scale, l.delta, 1, net.delta, 1);
}

#ifdef GPU

void pull_cost_layer(cost_layer l)
{
    cuda_pull_array(l.delta_gpu, l.delta, l.batch*l.inputs);
}

void push_cost_layer(cost_layer l)
{
    cuda_push_array(l.delta_gpu, l.delta, l.batch*l.inputs);
}

int float_abs_compare (const void * a, const void * b)
{
    float fa = *(const float*) a;
    if(fa < 0) fa = -fa;
    float fb = *(const float*) b;
    if(fb < 0) fb = -fb;
    return (fa > fb) - (fa < fb);
}

void forward_cost_layer_gpu(cost_layer l, network net)
{
    if (!net.truth) return;
    if(l.smooth){
        scal_gpu(l.batch*l.inputs, (1-l.smooth), net.truth_gpu, 1);
        add_gpu(l.batch*l.inputs, l.smooth * 1./l.inputs, net.truth_gpu, 1);
    }

    if(l.cost_type == SMOOTH){
        smooth_l1_gpu(l.batch*l.inputs, net.input_gpu, net.truth_gpu, l.delta_gpu, l.output_gpu);
    } else if (l.cost_type == L1){
        l1_gpu(l.batch*l.inputs, net.input_gpu, net.truth_gpu, l.delta_gpu, l.output_gpu);
    } else if (l.cost_type == WGAN){
        wgan_gpu(l.batch*l.inputs, net.input_gpu, net.truth_gpu, l.delta_gpu, l.output_gpu);
    } else {
        l2_gpu(l.batch*l.inputs, net.input_gpu, net.truth_gpu, l.delta_gpu, l.output_gpu);
    }

    if (l.cost_type == SEG && l.noobject_scale != 1) {
        scale_mask_gpu(l.batch*l.inputs, l.delta_gpu, 0, net.truth_gpu, l.noobject_scale);
        scale_mask_gpu(l.batch*l.inputs, l.output_gpu, 0, net.truth_gpu, l.noobject_scale);
    }
    if (l.cost_type == MASKED) {
        mask_gpu(l.batch*l.inputs, net.delta_gpu, SECRET_NUM, net.truth_gpu, 0);
    }

    if(l.ratio){
        cuda_pull_array(l.delta_gpu, l.delta, l.batch*l.inputs);
        qsort(l.delta, l.batch*l.inputs, sizeof(float), float_abs_compare);
        int n = (1-l.ratio) * l.batch*l.inputs;
        float thresh = l.delta[n];
        thresh = 0;
        printf("%f\n", thresh);
        supp_gpu(l.batch*l.inputs, thresh, l.delta_gpu, 1);
    }

    if(l.thresh){
        supp_gpu(l.batch*l.inputs, l.thresh*1./l.inputs, l.delta_gpu, 1);
    }

    cuda_pull_array(l.output_gpu, l.output, l.batch*l.inputs);
    l.cost[0] = sum_array(l.output, l.batch*l.inputs);
}

void backward_cost_layer_gpu(const cost_layer l, network net)
{
    axpy_gpu(l.batch*l.inputs, l.scale, l.delta_gpu, 1, net.delta_gpu, 1);
}
#endif

完,