深度学习 | 分类任务中类别不均衡解决策略（附代码）

爱被打了一巴掌 2022-03-25 10:24 215阅读 0赞

#### 0.前言 ####

在解决一个分类问题时，遇到样本不平衡问题。查找CSDN后，以及知乎后，发现网上有很多类似于欠采样 ，重复采样，换模型等等宏观的概念，并没有太多可实际应用（代码）的策略。经过一番查找和调试和修改，最终找到3个相对靠谱的策略，故总结此文给有需要同志，策略均来自网络，本人只是进行了部分代码修改和可用性测试。以下将简单介绍各个策略的机制以及对应代码（亲测能跑通）。

> NOTE：下述代码均是基于caffe的，而且实现策略都是通过新增自定义层。主要流程大致为：修改caffe.proto–>导入hpp/cpp/cu–>重新编译–>执行。具体请看：[Caffe | 自定义字段和层][Caffe _]。

#### 1.带权重的softmaxLoss ####

在样本不均衡分类问题中，样本量大的类别往往会主导训练过程，因为其累积loss会比较大。带权重的softmaxloss函数通过加权来决定主导训练的类别。在具体的实现过程中增加pos\_mult字段（指定某类的权重乘子）和pos\_cid字段（指定的某类的类别编号）两个参数来确定类别和当前类别的系数，通过系数来控制当前类别在反向传播中的重要性。（若pos\_mult=0.5，就表示当然类别重要度减半）。

代码实现[github传送门][github]

（1）修改caffe.proto文件  
编辑src/caffe/proto/caffe.proto，主要是在原有的SoftmaxParameter上添加了pos\_mul和pos\_cid字段。

// Message that stores parameters used by SoftmaxLayer, SoftmaxWithLossLayer
    message SoftmaxParameter {
      enum Engine {
        DEFAULT = 0;
        CAFFE = 1;
        CUDNN = 2;
      }
      optional Engine engine = 1 [default = DEFAULT];
    
      // The axis along which to perform the softmax -- may be negative to index
      // from the end (e.g., -1 for the last axis).
      // Any other axes will be evaluated as independent softmaxes.
      optional int32 axis = 2 [default = 1];
      optional float pos_mult = 3 [default = 1];
      optional int32 pos_cid = 4 [default = 1];
    }

（2）导入hpp/cpp/cu文件  
weighted\_softmax\_loss\_layer.hpp

#ifndef CAFFE_WEIGHTED_SOFTMAX_LOSS_LAYER_HPP_
    #define CAFFE_WEIGHTED_SOFTMAX_LOSS_LAYER_HPP_
    
    #include <vector>
    
    #include "caffe/blob.hpp"
    #include "caffe/layer.hpp"
    #include "caffe/proto/caffe.pb.h"
    
    #include "caffe/layers/loss_layer.hpp"
    #include "caffe/layers/softmax_layer.hpp"
    
    namespace caffe {
    
    /**
     * @brief A weighted version of SoftmaxWithLossLayer.
     *
     * TODO: Add description. Add the formulation in math.
     */
    template <typename Dtype>
    class WeightedSoftmaxWithLossLayer : public LossLayer<Dtype> {
     public:
       /**
        * @param param provides LossParameter loss_param, with options:
        *  - ignore_label (optional)
        *    Specify a label value that should be ignored when computing the loss.
        *  - normalize (optional, default true)
        *    If true, the loss is normalized by the number of (nonignored) labels
        *    present; otherwise the loss is simply summed over spatial locations.
        */
      explicit WeightedSoftmaxWithLossLayer(const LayerParameter& param)
          : LossLayer<Dtype>(param) {}
      virtual void LayerSetUp(const vector<Blob<Dtype>*>& bottom,
          const vector<Blob<Dtype>*>& top);
      virtual void Reshape(const vector<Blob<Dtype>*>& bottom,
          const vector<Blob<Dtype>*>& top);
    
      virtual inline const char* type() const { return "WeightedSoftmaxWithLoss"; }
      virtual inline int ExactNumBottomBlobs() const { return -1; }
      virtual inline int MinBottomBlobs() const { return 1; }
      virtual inline int MaxBottomBlobs() const { return 2; }
      virtual inline int ExactNumTopBlobs() const { return -1; }
      virtual inline int MinTopBlobs() const { return 1; }
      virtual inline int MaxTopBlobs() const { return 2; }
    
     protected:
      /// @copydoc WeightedSoftmaxWithLossLayer
      virtual void Forward_cpu(const vector<Blob<Dtype>*>& bottom,
          const vector<Blob<Dtype>*>& top);
      virtual void Forward_gpu(const vector<Blob<Dtype>*>& bottom,
          const vector<Blob<Dtype>*>& top);
      /**
       * @brief Computes the softmax loss error gradient w.r.t. the predictions.
       *
       * Gradients cannot be computed with respect to the label inputs (bottom[1]),
       * so this method ignores bottom[1] and requires !propagate_down[1], crashing
       * if propagate_down[1] is set.
       *
       * @param top output Blob vector (length 1), providing the error gradient with
       *      respect to the outputs
       *   -# @f$ (1 \times 1 \times 1 \times 1) @f$
       *      This Blob's diff will simply contain the loss_weight* @f$ \lambda @f$,
       *      as @f$ \lambda @f$ is the coefficient of this layer's output
       *      @f$\ell_i@f$ in the overall Net loss
       *      @f$ E = \lambda_i \ell_i + \mbox{other loss terms}@f$; hence
       *      @f$ \frac{\partial E}{\partial \ell_i} = \lambda_i @f$.
       *      (*Assuming that this top Blob is not used as a bottom (input) by any
       *      other layer of the Net.)
       * @param propagate_down see Layer::Backward.
       *      propagate_down[1] must be false as we can't compute gradients with
       *      respect to the labels.
       * @param bottom input Blob vector (length 2)
       *   -# @f$ (N \times C \times H \times W) @f$
       *      the predictions @f$ x @f$; Backward computes diff
       *      @f$ \frac{\partial E}{\partial x} @f$
       *   -# @f$ (N \times 1 \times 1 \times 1) @f$
       *      the labels -- ignored as we can't compute their error gradients
       */
      virtual void Backward_cpu(const vector<Blob<Dtype>*>& top,
          const vector<bool>& propagate_down, const vector<Blob<Dtype>*>& bottom);
      virtual void Backward_gpu(const vector<Blob<Dtype>*>& top,
          const vector<bool>& propagate_down, const vector<Blob<Dtype>*>& bottom);
    
    /// Read the normalization mode parameter and compute the normalizer based
      /// on the blob size.  If normalization_mode is VALID, the count of valid
      /// outputs will be read from valid_count, unless it is -1 in which case
      /// all outputs are assumed to be valid.
      virtual Dtype get_normalizer(
          LossParameter_NormalizationMode normalization_mode, int valid_count);
    
      /// The internal SoftmaxLayer used to map predictions to a distribution.
      shared_ptr<Layer<Dtype> > softmax_layer_;
      /// prob stores the output probability predictions from the SoftmaxLayer.
      Blob<Dtype> prob_;
      /// bottom vector holder used in call to the underlying SoftmaxLayer::Forward
      vector<Blob<Dtype>*> softmax_bottom_vec_;
      /// top vector holder used in call to the underlying SoftmaxLayer::Forward
      vector<Blob<Dtype>*> softmax_top_vec_;
      /// Whether to ignore instances with a certain label.
      bool has_ignore_label_;
      /// The label indicating that an instance should be ignored.
      int ignore_label_;
      /// How to normalize the output loss.
      LossParameter_NormalizationMode normalization_;
      
      int softmax_axis_, outer_num_, inner_num_;
    
      float pos_mult_;
      int pos_cid_;
    };
    
    
    }  // namespace caffe
    
    #endif  // CAFFE_WEIGHTED_SOFTMAX_LOSS_LAYER_HPP_

weighted\_softmax\_loss\_layer.cpp

#include <algorithm>
    #include <cfloat>
    #include <vector>
    
    #include "caffe/layers/weighted_softmax_loss_layer.hpp"
    #include "caffe/util/math_functions.hpp"
    
    namespace caffe {
    
    template <typename Dtype>
    void WeightedSoftmaxWithLossLayer<Dtype>::LayerSetUp(
        const vector<Blob<Dtype>*>& bottom, const vector<Blob<Dtype>*>& top) {
      LossLayer<Dtype>::LayerSetUp(bottom, top);
      LayerParameter softmax_param(this->layer_param_);
      softmax_param.set_type("Softmax");
      softmax_layer_ = LayerRegistry<Dtype>::CreateLayer(softmax_param);
      softmax_bottom_vec_.clear();
      softmax_bottom_vec_.push_back(bottom[0]);
      softmax_top_vec_.clear();
      softmax_top_vec_.push_back(&prob_);
      softmax_layer_->SetUp(softmax_bottom_vec_, softmax_top_vec_);
      pos_mult_ = this->layer_param_.softmax_param().pos_mult();
      pos_cid_ = this->layer_param_.softmax_param().pos_cid();
    
      LOG(INFO) << "mult: " << pos_mult_ << ", id: " << pos_cid_;
    
      has_ignore_label_ =
        this->layer_param_.loss_param().has_ignore_label();
      if (has_ignore_label_) {
        ignore_label_ = this->layer_param_.loss_param().ignore_label();
      }
      if (!this->layer_param_.loss_param().has_normalization() &&
          this->layer_param_.loss_param().has_normalize()) {
        normalization_ = this->layer_param_.loss_param().normalize() ?
                         LossParameter_NormalizationMode_VALID :
                         LossParameter_NormalizationMode_BATCH_SIZE;
      } else {
        normalization_ = this->layer_param_.loss_param().normalization();
      }
    }
    
    template <typename Dtype>
    void WeightedSoftmaxWithLossLayer<Dtype>::Reshape(
        const vector<Blob<Dtype>*>& bottom, const vector<Blob<Dtype>*>& top) {
      LossLayer<Dtype>::Reshape(bottom, top);
      softmax_layer_->Reshape(softmax_bottom_vec_, softmax_top_vec_);
      softmax_axis_ =
          bottom[0]->CanonicalAxisIndex(this->layer_param_.softmax_param().axis());
      outer_num_ = bottom[0]->count(0, softmax_axis_);
      inner_num_ = bottom[0]->count(softmax_axis_ + 1);
      //LOG(INFO) << "outer_num_: " << outer_num_ << ", inner_num_: " << inner_num_;
    
      CHECK_EQ(outer_num_ * inner_num_, bottom[1]->count())
          << "Number of labels must match number of predictions; "
          << "e.g., if softmax axis == 1 and prediction shape is (N, C, H, W), "
          << "label count (number of labels) must be N*H*W, "
          << "with integer values in {0, 1, ..., C-1}.";
      if (top.size() >= 2) {
        // softmax output
        top[1]->ReshapeLike(*bottom[0]);
      }
    }
    
    template <typename Dtype>
    Dtype WeightedSoftmaxWithLossLayer<Dtype>::get_normalizer(
        LossParameter_NormalizationMode normalization_mode, int valid_count) {
      Dtype normalizer;
      switch (normalization_mode) {
        case LossParameter_NormalizationMode_FULL:
          normalizer = Dtype(outer_num_ * inner_num_);
          break;
        case LossParameter_NormalizationMode_VALID:
          if (valid_count == -1) {
            normalizer = Dtype(outer_num_ * inner_num_);
          } else {
            normalizer = Dtype(valid_count);
          }
          break;
        case LossParameter_NormalizationMode_BATCH_SIZE:
          normalizer = Dtype(outer_num_);
          break;
        case LossParameter_NormalizationMode_NONE:
          normalizer = Dtype(1);
          break;
        default:
          LOG(FATAL) << "Unknown normalization mode: "
              << LossParameter_NormalizationMode_Name(normalization_mode);
      }
      // Some users will have no labels for some examples in order to 'turn off' a
      // particular loss in a multi-task setup. The max prevents NaNs in that case.
      return std::max(Dtype(1.0), normalizer);
    }
    
    template <typename Dtype>
    void WeightedSoftmaxWithLossLayer<Dtype>::Forward_cpu(
        const vector<Blob<Dtype>*>& bottom, const vector<Blob<Dtype>*>& top) {
      // The forward pass computes the softmax prob values.
      softmax_layer_->Forward(softmax_bottom_vec_, softmax_top_vec_);
      const Dtype* prob_data = prob_.cpu_data();
      const Dtype* label = bottom[1]->cpu_data();
      
       int dim = prob_.count() / outer_num_;
       int count = 0;
       Dtype loss = 0;
       LOG(INFO) << "dim:" << dim;
    
       for (int i = 0; i < outer_num_; ++i) {
          for (int j = 0; j < inner_num_; j++) {
          const int label_value = static_cast<int>(label[i * inner_num_ + j]);
          if (has_ignore_label_ && label_value == ignore_label_) {
            continue;
          }
          DCHECK_GE(label_value, 0);
          DCHECK_LT(label_value, prob_.shape(softmax_axis_));
          Dtype w = (label_value == pos_cid_) ? pos_mult_ : 1;
          loss -= w * log(std::max(prob_data[i * dim + label_value * inner_num_ + j],
                                   Dtype(FLT_MIN)));
          ++count;
        }
      }
      top[0]->mutable_cpu_data()[0] = loss / get_normalizer(normalization_, count);
      if (top.size() == 2) {
        top[1]->ShareData(prob_);
      }
    }
    
    template <typename Dtype>
    void WeightedSoftmaxWithLossLayer<Dtype>::Backward_cpu(const vector<Blob<Dtype>*>& top,
        const vector<bool>& propagate_down, const vector<Blob<Dtype>*>& bottom) {
      if (propagate_down[1]) {
        LOG(FATAL) << this->type()
                   << " Layer cannot backpropagate to label inputs.";
      }
      if (propagate_down[0]) {
        Dtype* bottom_diff = bottom[0]->mutable_cpu_diff();
        const Dtype* prob_data = prob_.cpu_data();
        caffe_copy(prob_.count(), prob_data, bottom_diff);
        const Dtype* label = bottom[1]->cpu_data();
    
        int dim = prob_.count() / outer_num_;
    
        int count = 0;
        for (int i = 0; i < outer_num_; ++i) {
          for (int j = 0; j < inner_num_; ++j) {
            const int label_value = static_cast<int>(label[i * inner_num_ + j]);
            if (has_ignore_label_ && label_value == ignore_label_) {
              for (int c = 0; c < bottom[0]->shape(softmax_axis_); ++c) {
                bottom_diff[i * dim + c * inner_num_ + j] = 0;
              }
            } else {
              bottom_diff[i * dim + label_value * inner_num_ + j] -= 1;
              Dtype w = (label_value == pos_cid_) ? pos_mult_ : 1;
              for (int k = 0; k < bottom[0]->shape(softmax_axis_); ++k) {
                bottom_diff[i * dim + k * inner_num_ + j] *= w;
              }
              ++count;
            }
          }
        }
        // Scale gradient
        Dtype loss_weight = top[0]->cpu_diff()[0] /
                            get_normalizer(normalization_, count);
        caffe_scal(prob_.count(), loss_weight, bottom_diff);
      }
    }
    
    
    #ifdef CPU_ONLY
    STUB_GPU(WeightedSoftmaxWithLossLayer);
    #endif
    
    INSTANTIATE_CLASS(WeightedSoftmaxWithLossLayer);
    REGISTER_LAYER_CLASS(WeightedSoftmaxWithLoss);
    }  // namespace caffe

weighted\_softmax\_loss\_layer.cu

#include <algorithm>
    #include <cfloat>
    #include <vector>
    
    #include "caffe/layers/weighted_softmax_loss_layer.hpp"
    #include "caffe/util/math_functions.hpp"
    
    namespace caffe {
    
    template <typename Dtype>
    __global__ void WeightedSoftmaxLossForwardGPU(const int nthreads,
              const Dtype* prob_data, const Dtype* label, Dtype* loss,
    	  const Dtype pos_mult_, const int pos_cid_,
              const int num, const int dim, const int spatial_dim,
              const bool has_ignore_label_, const int ignore_label_,
              Dtype* counts) {
      CUDA_KERNEL_LOOP(index, nthreads) {
        const int n = index / spatial_dim;
        const int s = index % spatial_dim;
        const int label_value = static_cast<int>(label[n * spatial_dim + s]);
        Dtype w = (label_value == pos_cid_) ? pos_mult_ : 1;
        if (has_ignore_label_ && label_value == ignore_label_) {
          loss[index] = 0;
          counts[index] = 0;
        } else {
          loss[index] = -w * log(max(prob_data[n * dim + label_value * spatial_dim + s],
                                     Dtype(FLT_MIN)));
          counts[index] = 1;
        }
      }
    }
    
    template <typename Dtype>
    void WeightedSoftmaxWithLossLayer<Dtype>::Forward_gpu(
        const vector<Blob<Dtype>*>& bottom, const vector<Blob<Dtype>*>& top) {
      softmax_layer_->Forward(softmax_bottom_vec_, softmax_top_vec_);
      const Dtype* prob_data = prob_.gpu_data();
      const Dtype* label = bottom[1]->gpu_data();
    
      const int dim = prob_.count() / outer_num_;
      const int nthreads = outer_num_ * inner_num_;
      // Since this memory is not used for anything until it is overwritten
      // on the backward pass, we use it here to avoid having to allocate new GPU
      // memory to accumulate intermediate results in the kernel.
      Dtype* loss_data = bottom[0]->mutable_gpu_diff();
      // Similarly, this memory is never used elsewhere, and thus we can use it
      // to avoid having to allocate additional GPU memory.
      Dtype* counts = prob_.mutable_gpu_diff();
      // NOLINT_NEXT_LINE(whitespace/operators)
      WeightedSoftmaxLossForwardGPU<Dtype><<<CAFFE_GET_BLOCKS(nthreads),
          CAFFE_CUDA_NUM_THREADS>>>(nthreads, prob_data, label, loss_data,
          pos_mult_, pos_cid_, 
          outer_num_, dim, inner_num_, has_ignore_label_, ignore_label_, counts);
      Dtype loss;
      caffe_gpu_asum(nthreads, loss_data, &loss);
      Dtype valid_count = -1;
      // Only launch another CUDA kernel if we actually need the count of valid
      // outputs.
      if (normalization_ == LossParameter_NormalizationMode_VALID &&
          has_ignore_label_) {
        caffe_gpu_asum(nthreads, counts, &valid_count);
      }
      top[0]->mutable_cpu_data()[0] = loss / get_normalizer(normalization_,
                                                            valid_count);
      if (top.size() == 2) {
        top[1]->ShareData(prob_);
      }
    }
    
    template <typename Dtype>
    __global__ void WeightedSoftmaxLossBackwardGPU(const int nthreads, const Dtype* top,
              const Dtype* label, Dtype* bottom_diff, 
    	  const Dtype pos_mult_, const int pos_cid_,
    	  const int num, const int dim,
              const int spatial_dim, const bool has_ignore_label_,
              const int ignore_label_, Dtype* counts) {
      const int channels = dim / spatial_dim;
    
      CUDA_KERNEL_LOOP(index, nthreads) {
        const int n = index / spatial_dim;
        const int s = index % spatial_dim;
        const int label_value = static_cast<int>(label[n * spatial_dim + s]);
        Dtype w = (label_value == pos_cid_) ? pos_mult_ : 1;
    
        if (has_ignore_label_ && label_value == ignore_label_) {
          for (int c = 0; c < channels; ++c) {
            bottom_diff[n * dim + c * spatial_dim + s] = 0;
          }
          counts[index] = 0;
        } else {
          bottom_diff[n * dim + label_value * spatial_dim + s] -= 1;
          counts[index] = 1;
          for (int c = 0; c < channels; ++c) {
            bottom_diff[n * dim + c * spatial_dim + s] *= w;
          }
        }
      }
    }
    
    template <typename Dtype>
    void WeightedSoftmaxWithLossLayer<Dtype>::Backward_gpu(const vector<Blob<Dtype>*>& top,
        const vector<bool>& propagate_down, const vector<Blob<Dtype>*>& bottom) {
      if (propagate_down[1]) {
        LOG(FATAL) << this->type()
                   << " Layer cannot backpropagate to label inputs.";
      }
      if (propagate_down[0]) {
        Dtype* bottom_diff = bottom[0]->mutable_gpu_diff();
        const Dtype* prob_data = prob_.gpu_data();
        const Dtype* top_data = top[0]->gpu_data();
        caffe_gpu_memcpy(prob_.count() * sizeof(Dtype), prob_data, bottom_diff);
        const Dtype* label = bottom[1]->gpu_data();
    
        const int dim = prob_.count() / outer_num_;
        const int nthreads = outer_num_ * inner_num_;
        // Since this memory is never used for anything else,
        // we use to to avoid allocating new GPU memory.
        Dtype* counts = prob_.mutable_gpu_diff();
        // NOLINT_NEXT_LINE(whitespace/operators)
        WeightedSoftmaxLossBackwardGPU<Dtype><<<CAFFE_GET_BLOCKS(nthreads),
            CAFFE_CUDA_NUM_THREADS>>>(nthreads, top_data, label, bottom_diff,
    	      pos_mult_, pos_cid_, outer_num_, dim, inner_num_, has_ignore_label_,
            ignore_label_, counts);
        Dtype valid_count = -1;
        // Only launch another CUDA kernel if we actually need the count of valid
        // outputs.
        if (normalization_ == LossParameter_NormalizationMode_VALID &&
            has_ignore_label_) {
          caffe_gpu_asum(nthreads, counts, &valid_count);
        }
        const Dtype loss_weight = top[0]->cpu_diff()[0] /
                                  get_normalizer(normalization_, valid_count);
        caffe_gpu_scal(prob_.count(), loss_weight , bottom_diff);
      }
    }
    
    INSTANTIATE_LAYER_GPU_FUNCS(WeightedSoftmaxWithLossLayer);
    
    }  // namespace caffe

（3）编译

（4）使用方法

layer {
      name: "loss"
      type: "WeightedSoftmaxWithLoss"
      bottom: "fc_end"
      bottom: "label"
      top: "loss"
      softmax_param {
        pos_cid: 1
        pos_mult: 0.5
      }
    }

需要注意的是pos\_cid也是从0开始的，若指定为0表示pos\_mult的参数将乘到对应的类别中，简而言之就是和标签对应，对应代码如下。

Dtype w = (label_value == pos_cid_) ? pos_mult_ : 1;

#### 2.OHEMLoss ####

OHEM被称为难例挖掘,针对模型训练过程中导致损失值很大的一些样本(即使模型很大概率分类错误的样本),重新训练它们.维护一个错误分类样本池, 把每个batch训练数据中的出错率很大的样本放入该样本池中,当积累到一个batch以后,将这些样本放回网络重新训练。通俗的讲OHEM就是加强loss大样本的训练。

代码实现[查看上一篇文章：Caffe | 自定义字段和层][Caffe _]

（1）修改caffe.proto文件

（2）导入hpp/cpp/cu文件

（3）编译

（4）使用方法

#### 3.focalLoss ####

该loss就是是在带权重的基础上作出了改进，解决样本不平衡问题的，总体思想和带权重的有点类似， focal loss首先解决的就是样本不平衡的问题，类似于softmaxloss。即在CE上加权重，当class为1的时候，乘以权重alpha，当class为0的时候，乘以权重1-alpha，这是最基本的解决样本不平衡的方法，也就是在loss计算时乘以权重。

![aHR0cHM6Ly91cGxvYWQtaW1hZ2VzLmppYW5zaHUuaW8vdXBsb2FkX2ltYWdlcy81NTI5OTk3LTk5Njk5MmQzMmI3MDFiMjcucG5n][]

在此基础上，focalloss的核心就是在CE的前面乘上了（1-pt）的gama次方。pt就是准确率，因此该公式表示的含义为：准确率越高 ，整个loss值就越小。所以我们把参数gama称为衰减系数，准确率越高的类衰减的越厉害。这就是的准确率低的类能够占据loss的大部分，并主导训练。

![aHR0cHM6Ly91cGxvYWQtaW1hZ2VzLmppYW5zaHUuaW8vdXBsb2FkX2ltYWdlcy81NTI5OTk3LTE0NmRhMjA3YTU5ZTA1YTUucG5n][]

而第二种方法OHEM是让loss大的进行主导。两者在这个机制上殊途同归。但OHEM的缺点是其只取一部分多数样本进行loss计算来实现上述功能，而focalloss则作用于所有样本。最终focalloss的公式如下：  
![aHR0cHM6Ly91cGxvYWQtaW1hZ2VzLmppYW5zaHUuaW8vdXBsb2FkX2ltYWdlcy81NTI5OTk3LWI1OTc2MzkxM2NlYTYyMDYucG5n][]

代码实现[github传送门][github 1]

（1）修改caffe.proto文件

// Focal Loss layer
    optional FocalLossParameter focal_loss_param = 145;//需要和自己的protobuf序列号对应，不能产生冲突
    //否则会报错：Field number 124 has already been used in “caffe.LayerParameter” by field "focal_loss_param"
    
    // Focal Loss for Dense Object Detection
    message FocalLossParameter {
      enum Type {
        ORIGIN = 0; // FL(p_t)  = -(1 - p_t) ^ gama * log(p_t), where p_t = p if y == 1 else 1 - p, whre p = sigmoid(x)
        LINEAR = 1; // FL*(p_t) = -log(p_t) / gama, where p_t = sigmoid(gama * x_t + beta), where x_t = x * y, y is the ground truth label {-1, 1}
      }
      optional Type type   = 1 [default = ORIGIN]; 
      optional float gamma = 2 [default = 2];
      // cross-categories weights to solve the imbalance problem
      optional float alpha = 3 [default = 0.25]; 
      optional float beta  = 4 [default = 1.0];
    }

（2）导入hpp/cpp/cu文件

（3）编译

（4）使用方法

layer {
      name: "loss_cls"
      type: "FocalLoss"
      bottom: "cls_score"
      bottom: "labels"
      propagate_down: 1
      propagate_down: 0
      top: "loss_cls"
      include { phase: TRAIN }
      loss_weight: 1
      loss_param { ignore_label: -1 normalize: true }
      focal_loss_param { alpha: 0.25 gamma: 2 }
    }

[Caffe _]: https://www.jianshu.com/p/c79816c1c915
[github]: https://github.com/qiu931110/Weighted_Softmax_Loss
[aHR0cHM6Ly91cGxvYWQtaW1hZ2VzLmppYW5zaHUuaW8vdXBsb2FkX2ltYWdlcy81NTI5OTk3LTk5Njk5MmQzMmI3MDFiMjcucG5n]: /images/20220325/03f020a1de8944048fa0c471b8cefda7.png
[aHR0cHM6Ly91cGxvYWQtaW1hZ2VzLmppYW5zaHUuaW8vdXBsb2FkX2ltYWdlcy81NTI5OTk3LTE0NmRhMjA3YTU5ZTA1YTUucG5n]: /images/20220325/c42eba603fa3431980bad456af168778.png
[aHR0cHM6Ly91cGxvYWQtaW1hZ2VzLmppYW5zaHUuaW8vdXBsb2FkX2ltYWdlcy81NTI5OTk3LWI1OTc2MzkxM2NlYTYyMDYucG5n]: /images/20220325/0c468ab2743a43a18c32c298f7c16394.png
[github 1]: https://github.com/qiu931110/Focal-Loss