CenterLoss的caffe实现

最新推荐文章于 2020-08-15 22:54:02 发布
最新推荐文章于 2020-08-15 22:54:02 发布
阅读量851 收藏 2
点赞数
分类专栏： 人脸检测 目标检测 深度学习通用策略 文章标签： caffe

github的地址：https://github.com/ydwen/caffe-face

CenterLoss_layer可以在原分类的基础上（某种程度上）可提升几个点左右（博主测试提升6个点），还不占前向时间，好东西啊！

原理这里不介绍了，网上应有尽有！这里只是介绍如何在caffe中如何添加CenterLoss_layer这样的新层！


第一步：修改caffe.proto以添加消息机制

1、在message LayerParameter{}中添加如下代码：

[cpp]  view plain  copy
  1. optional CenterLossParameter center_loss_param = 147;  

2、在 caffe.proto文末 添加

[cpp]  view plain  copy
  1. message CenterLossParameter {  
  2.   optional uint32 num_output = 1; // The number of outputs for the layer  
  3.   optional FillerParameter center_filler = 2; // The filler for the centers  
  4.   // The first axis to be lumped into a single inner product computation;  
  5.   // all preceding axes are retained in the output.  
  6.   // May be negative to index from the end (e.g., -1 for the last axis).  
  7.   optional int32 axis = 3 [default = 1];  
  8. }  


第二步：添加头文件center_loss_layer.hpp

[cpp]  view plain  copy
  1. #ifndef CAFFE_CENTER_LOSS_LAYER_HPP_  
  2. #define CAFFE_CENTER_LOSS_LAYER_HPP_  
  3.   
  4. #include <vector>  
  5.   
  6. #include "caffe/blob.hpp"  
  7. #include "caffe/layer.hpp"  
  8. #include "caffe/proto/caffe.pb.h"  
  9.   
  10. #include "caffe/layers/loss_layer.hpp"  
  11.   
  12. namespace caffe {  
  13.   
  14. template <typename Dtype>  
  15. class CenterLossLayer : public LossLayer<Dtype> {  
  16.  public:  
  17.   explicit CenterLossLayer(const LayerParameter& param)  
  18.       : LossLayer<Dtype>(param) {}  
  19.   virtual void LayerSetUp(const vector<Blob<Dtype>*>& bottom,  
  20.       const vector<Blob<Dtype>*>& top);  
  21.   virtual void Reshape(const vector<Blob<Dtype>*>& bottom,  
  22.       const vector<Blob<Dtype>*>& top);  
  23.   
  24.   virtual inline const char* type() const { return "CenterLoss"; }  
  25.   virtual inline int ExactNumBottomBlobs() const { return 2; }  
  26.   virtual inline int ExactNumTopBlobs() const { return -1; }  
  27.   
  28.  protected:  
  29.   virtual void Forward_cpu(const vector<Blob<Dtype>*>& bottom,  
  30.       const vector<Blob<Dtype>*>& top);  
  31.   virtual void Forward_gpu(const vector<Blob<Dtype>*>& bottom,  
  32.       const vector<Blob<Dtype>*>& top);  
  33.   virtual void Backward_cpu(const vector<Blob<Dtype>*>& top,  
  34.       const vector<bool>& propagate_down, const vector<Blob<Dtype>*>& bottom);  
  35.   virtual void Backward_gpu(const vector<Blob<Dtype>*>& top,  
  36.       const vector<bool>& propagate_down, const vector<Blob<Dtype>*>& bottom);  
  37.   
  38.   int M_;  
  39.   int K_;  
  40.   int N_;  
  41.     
  42.   Blob<Dtype> distance_;  
  43.   Blob<Dtype> variation_sum_;  
  44. };  
  45.   
  46. }  // namespace caffe  
  47.   
  48. #endif  // CAFFE_CENTER_LOSS_LAYER_HPP_  


第三步：添加center_loss_layer.cpp以及center_loss_layer.cu

[cpp]  view plain  copy
  1. #include <vector>  
  2.   
  3. #include "caffe/filler.hpp"  
  4. #include "caffe/layers/center_loss_layer.hpp"  
  5. #include "caffe/util/math_functions.hpp"  
  6.   
  7. namespace caffe {  
  8.   
  9. template <typename Dtype>  
  10. void CenterLossLayer<Dtype>::LayerSetUp(const vector<Blob<Dtype>*>& bottom,  
  11.       const vector<Blob<Dtype>*>& top) {  
  12.   const int num_output = this->layer_param_.center_loss_param().num_output();    
  13.   N_ = num_output;  
  14.   const int axis = bottom[0]->CanonicalAxisIndex(  
  15.       this->layer_param_.center_loss_param().axis());  
  16.   // Dimensions starting from "axis" are "flattened" into a single  
  17.   // length K_ vector. For example, if bottom[0]'s shape is (N, C, H, W),  
  18.   // and axis == 1, N inner products with dimension CHW are performed.  
  19.   K_ = bottom[0]->count(axis);  
  20.   // Check if we need to set up the weights  
  21.   if (this->blobs_.size() > 0) {  
  22.     LOG(INFO) << "Skipping parameter initialization";  
  23.   } else {  
  24.     this->blobs_.resize(1);  
  25.     // Intialize the weight  
  26.     vector<int> center_shape(2);  
  27.     center_shape[0] = N_;  
  28.     center_shape[1] = K_;  
  29.     this->blobs_[0].reset(new Blob<Dtype>(center_shape));  
  30.     // fill the weights  
  31.     shared_ptr<Filler<Dtype> > center_filler(GetFiller<Dtype>(  
  32.         this->layer_param_.center_loss_param().center_filler()));  
  33.     center_filler->Fill(this->blobs_[0].get());  
  34.   
  35.   }  // parameter initialization  
  36.   this->param_propagate_down_.resize(this->blobs_.size(), true);  
  37. }  
  38.   
  39. template <typename Dtype>  
  40. void CenterLossLayer<Dtype>::Reshape(const vector<Blob<Dtype>*>& bottom,  
  41.       const vector<Blob<Dtype>*>& top) {  
  42.   CHECK_EQ(bottom[1]->channels(), 1);  
  43.   CHECK_EQ(bottom[1]->height(), 1);  
  44.   CHECK_EQ(bottom[1]->width(), 1);  
  45.   M_ = bottom[0]->num();  
  46.   // The top shape will be the bottom shape with the flattened axes dropped,  
  47.   // and replaced by a single axis with dimension num_output (N_).  
  48.   LossLayer<Dtype>::Reshape(bottom, top);  
  49.   distance_.ReshapeLike(*bottom[0]);  
  50.   variation_sum_.ReshapeLike(*this->blobs_[0]);  
  51. }  
  52.   
  53. template <typename Dtype>  
  54. void CenterLossLayer<Dtype>::Forward_cpu(const vector<Blob<Dtype>*>& bottom,  
  55.     const vector<Blob<Dtype>*>& top) {  
  56.   const Dtype* bottom_data = bottom[0]->cpu_data();  
  57.   const Dtype* label = bottom[1]->cpu_data();  
  58.   const Dtype* center = this->blobs_[0]->cpu_data();  
  59.   Dtype* distance_data = distance_.mutable_cpu_data();  
  60.     
  61.   // the i-th distance_data  
  62.   for (int i = 0; i < M_; i++) {  
  63.     const int label_value = static_cast<int>(label[i]);  
  64.     // D(i,:) = X(i,:) - C(y(i),:)  
  65.     caffe_sub(K_, bottom_data + i * K_, center + label_value * K_, distance_data + i * K_);  
  66.   }  
  67.   Dtype dot = caffe_cpu_dot(M_ * K_, distance_.cpu_data(), distance_.cpu_data());  
  68.   Dtype loss = dot / M_ / Dtype(2);  
  69.   top[0]->mutable_cpu_data()[0] = loss;  
  70. }  
  71.   
  72. template <typename Dtype>  
  73. void CenterLossLayer<Dtype>::Backward_cpu(const vector<Blob<Dtype>*>& top,  
  74.     const vector<bool>& propagate_down,  
  75.     const vector<Blob<Dtype>*>& bottom) {  
  76.   // Gradient with respect to centers  
  77.   if (this->param_propagate_down_[0]) {  
  78.     const Dtype* label = bottom[1]->cpu_data();  
  79.     Dtype* center_diff = this->blobs_[0]->mutable_cpu_diff();  
  80.     Dtype* variation_sum_data = variation_sum_.mutable_cpu_data();  
  81.     const Dtype* distance_data = distance_.cpu_data();  
  82.   
  83.     // \sum_{y_i==j}  
  84.     caffe_set(N_ * K_, (Dtype)0., variation_sum_.mutable_cpu_data());  
  85.     for (int n = 0; n < N_; n++) {  
  86.       int count = 0;  
  87.       for (int m = 0; m < M_; m++) {  
  88.         const int label_value = static_cast<int>(label[m]);  
  89.         if (label_value == n) {  
  90.           count++;  
  91.           caffe_sub(K_, variation_sum_data + n * K_, distance_data + m * K_, variation_sum_data + n * K_);  
  92.         }  
  93.       }  
  94.       caffe_axpy(K_, (Dtype)1./(count + (Dtype)1.), variation_sum_data + n * K_, center_diff + n * K_);  
  95.     }  
  96.   }  
  97.   // Gradient with respect to bottom data   
  98.   if (propagate_down[0]) {  
  99.     caffe_copy(M_ * K_, distance_.cpu_data(), bottom[0]->mutable_cpu_diff());  
  100.     caffe_scal(M_ * K_, top[0]->cpu_diff()[0] / M_, bottom[0]->mutable_cpu_diff());  
  101.   }  
  102.   if (propagate_down[1]) {  
  103.     LOG(FATAL) << this->type()  
  104.                << " Layer cannot backpropagate to label inputs.";  
  105.   }  
  106. }  
  107.   
  108. #ifdef CPU_ONLY  
  109. STUB_GPU(CenterLossLayer);  
  110. #endif  
  111.   
  112. INSTANTIATE_CLASS(CenterLossLayer);  
  113. REGISTER_LAYER_CLASS(CenterLoss);  
  114.   
  115. }  // namespace caffe  

[cpp]  view plain  copy
  1. #include <vector>  
  2.   
  3. #include "caffe/filler.hpp"  
  4. #include "caffe/layers/center_loss_layer.hpp"  
  5. #include "caffe/util/math_functions.hpp"  
  6.   
  7. namespace caffe {  
  8.   
  9. template <typename Dtype>  
  10. __global__ void Compute_distance_data_gpu(int nthreads, const int K, const Dtype* bottom,  
  11.           const Dtype* label, const Dtype* center, Dtype* distance) {  
  12.   CUDA_KERNEL_LOOP(index, nthreads) {  
  13.     int m = index / K;  
  14.     int k = index % K;  
  15.     const int label_value = static_cast<int>(label[m]);  
  16.     // distance(i) = x(i) - c_{y(i)}  
  17.     distance[index] = bottom[index] - center[label_value * K + k];  
  18.   }  
  19. }  
  20.   
  21. template <typename Dtype>  
  22. __global__ void Compute_center_diff_gpu(int nthreads, const int M, const int K,   
  23.         const Dtype* label, const Dtype* distance, Dtype* variation_sum,   
  24.         Dtype* center_diff) {  
  25.   CUDA_KERNEL_LOOP(index, nthreads) {  
  26.     int count = 0;  
  27.     for (int m = 0; m < M; m++) {  
  28.       const int label_value = static_cast<int>(label[m]);  
  29.       if (label_value == index) {  
  30.         count++;  
  31.         for (int k = 0; k < K; k++) {  
  32.           variation_sum[index * K + k] -= distance[m * K + k];  
  33.         }  
  34.       }  
  35.     }  
  36.     for (int k = 0; k < K; k++) {  
  37.       center_diff[index * K + k] = variation_sum[index * K + k] /(count + (Dtype)1.);  
  38.     }  
  39.   }  
  40. }  
  41.   
  42.   
  43. template <typename Dtype>  
  44. void CenterLossLayer<Dtype>::Forward_gpu(const vector<Blob<Dtype>*>& bottom,  
  45.     const vector<Blob<Dtype>*>& top) {  
  46.   int nthreads = M_ * K_;  
  47.   Compute_distance_data_gpu<Dtype><<<CAFFE_GET_BLOCKS(nthreads),  
  48.       CAFFE_CUDA_NUM_THREADS>>>(nthreads, K_, bottom[0]->gpu_data(), bottom[1]->gpu_data(),  
  49.                                 this->blobs_[0]->gpu_data(), distance_.mutable_gpu_data());  
  50.   Dtype dot;  
  51.   caffe_gpu_dot(M_ * K_, distance_.gpu_data(), distance_.gpu_data(), &dot);  
  52.   Dtype loss = dot / M_ / Dtype(2);  
  53.   top[0]->mutable_cpu_data()[0] = loss;  
  54. }  
  55.   
  56. template <typename Dtype>  
  57. void CenterLossLayer<Dtype>::Backward_gpu(const vector<Blob<Dtype>*>& top,  
  58.     const vector<bool>& propagate_down,  
  59.     const vector<Blob<Dtype>*>& bottom) {  
  60.   int nthreads = N_;  
  61.   caffe_gpu_set(N_ * K_, (Dtype)0., variation_sum_.mutable_cpu_data());  
  62.   Compute_center_diff_gpu<Dtype><<<CAFFE_GET_BLOCKS(nthreads),  
  63.       CAFFE_CUDA_NUM_THREADS>>>(nthreads, M_, K_, bottom[1]->gpu_data(), distance_.gpu_data(),   
  64.                                 variation_sum_.mutable_cpu_data(), this->blobs_[0]->mutable_gpu_diff());  
  65.   
  66.   if (propagate_down[0]) {  
  67.     caffe_gpu_scale(M_ * K_, top[0]->cpu_diff()[0] / M_,   
  68.                              distance_.gpu_data(), bottom[0]->mutable_gpu_diff());  
  69.   }  
  70.   if (propagate_down[1]) {  
  71.     LOG(FATAL) << this->type()  
  72.                << " Layer cannot backpropagate to label inputs.";  
  73.   }  
  74. }  
  75.   
  76. INSTANTIATE_LAYER_GPU_FUNCS(CenterLossLayer);  
  77.   
  78. }  // namespace caffe  


第四步：重新编译caffe

BigCowPeking
关注
专栏目录
MobileNet DepthwiseConvolution、ShuffleNet shuffle channel、CenterLoss在Caffe下实现
jsk_learner的博客
07-12 1453
针对Caffe下特殊操作实现MobileNet-DepthwiseConvolution在Caffe下实现实现步骤源码：depthwise_conv_layer.hppdepthwise_conv_layer.cppdepthwise_conv_layer.cuShuffleNet通道混洗操作（shuffle channel）在Caffe下的实现实现步骤源码shuffle_channel_laye...
caffe-face(Center Loss工程源码).zip
02-21
本工程源码"caffe-face"是基于Caffe实现的一个特殊应用，专注于人脸识别。中心损失（Center Loss）是一种针对人脸识别问题的损失函数，它有助于改善模型在训练过程中的收敛性和识别准确性。 **中心损失（Center ...
论文阅读学习 - Center Loss: Caffe 实现
长风破浪会有时，直挂云帆济沧海
11-16 2444
Center Loss - Caffe实现
Center Loss caffe 实现
weixin_NineDays66
07-15 1496
  Center Loss  ECCV2016提出的center loss是通过将特征和特征中心的距离和softmax loss一同作为损失函数，使得类内距离更小，有点L1，L2正则化的意思。核心内容如下图所示： 接下来详细介绍center loss。如果你还是不熟悉传统的softmax loss，那么先来看看传统的softmax loss。首先区分softmax和softmax loss...
Caffe(caffe-fast-rcnn）配置Center Loss(其他网络层类似方法）
Muzythoof的博客
04-17 793
一、首先是配置CenterLoss原版的caffe是没有Centerloss这一层的。所以需要手动添加。参考博客：http://blog.csdn.net/samylee/article/details/76640240主要配置是一下几个文件：    src/caffe/proto/caffe.proto    include/caffe/layers/center_loss_layer.hpp ...
Caffe添加Center_Loss layer
m_buddy的博客
09-19 580
1. Caffe修改 1.1 修改caffe.proto 在message LayerParameter{}中添加如下代码： optional CenterLossParameter center_loss_param = 147; 在caffe.proto文末添加 message CenterLossParameter { optional uint32 num_output = 1; /...
基于多任务卷积网络(MTCNN)和Center-Loss的多人实时人脸检测和人脸识别系统 毕业设计
02-09
基于center loss 或者triplet loss原理开发人脸对比功能，模型采用ResNet inception v2. 该功能能够比较两张人脸图片的相似性。具体可以参考 Paper和FaceNet 反欺诈功能，根据光线，质地等人脸特性来防止照片攻击，...
center loss 翻译
qq_34714751的博客
01-01 1255
深度人脸识别的判别特征学习方法（Center Loss） 抽象 ​ 卷积神经网络（CNNs）已被广泛应用于计算机视觉领域，显着提高了现有技术水平。在大多数可用的CNN中，softmax损失函数被用作训练深度模型的监督信号。为了增强深度学习特征的判别力，本文提出了一种新的监督信号，称为中心丢失，用于人脸识别任务。具体而言，中心损失同时学习每个类别的深度特征的中心并且惩罚深度特征与其对应的类中心之间的...
CenterLoss的实现
kobayashi_的博客
08-15 721
论文 文章目录1.为什么要CenterLoss2.如何CenterLoss3.Centerloss 的代码实现 1.为什么要CenterLoss 首先在定义一个简单的全连接神经网络。为了更好的可视化特征，将网络的输出层的前一层的输出变为2，使之输出只有2个特征。接着，在MNIST数据集上进行训练，边训练，边可视化输出。 class SimpleFCNet(nn.Module): def __init__(self): super().__init__() self.fc1=nn.Sequ
人脸识别 Center Loss及实现
qq_39865109的博客
10-08 611
Center Loss 为什么用Center Loss？ 首先要声明的是Center Loss主要用于做人脸的识别，那么为什么不用softmax对人脸直接分类呢？因为人脸之间的特征是十分相似的，在类与类之间的交界处是很难区分开的，换句话说softmax分类两张人脸得到的概率值都是0.5左右，导致分类结果不准确。那么怎么把这种交界处区分开呢？有两种方法：1、第一种扩大类间距，2、第二种扩大类内距。C...
CenterLoss的caffe实现与深入理解
AlphaHolo的博客
07-11 3762
CenterLoss的caffe实现与深入理解 目的： 打算将centerloss与SSD的multibox_loss融合，或者与faster-rcnn的softmax回归融合。 项目代码将会发布到：https://github.com/BOBrown 思路概述： paper title:A Discriminative Feature Learning Approach for D...
采用center loss的caffe 人脸识别
walle的博客
06-21 3408
https://sanwen8.cn/p/446HEbm.html
center loss代码注释(caffe新添加层)
葫芦与瓢的博客
03-03 5249
#include <vector>#include "caffe/layers/center_loss_layer.hpp" #include "caffe/util/math_functions.hpp"namespace caffe{ template<typename Dtype> void CenterLossLayer<Dtype>::LayerSetUp(const ve
原始caffe添加CenterLoss_layer
samylee的博客
08-03 3183
CenterLoss_layer可以在原分类的基础上（某种程度上）可提升几个点左右（博主测试提升6个点），还不占前向时间，好东西啊！ 原理这里不介绍了，网上应有尽有！这里只是介绍如何在caffe中如何添加CenterLoss_layer这样的新层！
caffe中添加centerloss层，并在mnist上测试
村民的菜篮子
09-23 456
一、添加centerloss层 可参考github上的caffe工程：https://github.com/ydwen/caffe-face 添加hpp,cpp,cu文件，以及修改caffe.proto文件重新编译。 二、在mnist数据集上使用centerloss训练模型，测试效果 下面训练和测试的文件都是在上面的github中。 1、训练协议文件：mnist_train_test.p...
caffe源码解读(2)－center_loss_layer.cpp
冬后晚晴的博客
01-25 815
center_loss公式定义 center_loss_layer.cpp源码解读 center loss,softmax loss在mnist数据集上的对比实验 定义 “Center Loss: simultaneously learning a center for deep features of each class and penalizing the distances
windows caffe添加新层center loss layer
qq_34662616的博客
07-27 360
相关文件可见：https://github.com/ydwen/caffe-face 主要包括4个步骤： （1）src\caffe\caffe.proto里添加消息机制：proto格式的ID号（要求ID号唯一，不与其他ID重合即可）及相应定义          在message LayerParameter{}中添加如下ID号：          optional CenterLossPar...
centerloss 理解
专注于机器学习，深度学习，人脸识别领域。
07-26 7519
今天看了一下centerloss 源码 ，觉得还是挺值得借鉴的，所以分享一下。 centerloss主要在caffe的基础上加了三项。一. caffe.proto1.加proto 格式 的 ID号1472.加proto格式的定义 这里面的参数都是层的参数，也是超参，在prototxt中赋值。 axis是默认为1的。二.加入hpp 文件到include/caffe/layers/ ,主要包含
Caffe 实现LSTM
最新发布
03-31
然而，由于LSTM网络也是深度学习的一种形式，因此Caffe也可以用于实现LSTM网络。 在Caffe中，实现LSTM网络的步骤与实现卷积神经网络的步骤类似。主要的区别在于LSTM网络中的神经元类型和连接方式。 以下是一个简单...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值