修改caffe源代码从添加loss(层)函数开始

最新推荐文章于 2018-05-23 13:32:30 发布
最新推荐文章于 2018-05-23 13:32:30 发布
阅读量706 收藏
点赞数
分类专栏： caffe 文章标签： caffe

DeepLearning（基于caffe）实战项目（8）--修改caffe源代码从添加loss(层)函数开始

标签： Caffe实战项目LossLayer修改源代码
2017-05-27 19:03 479人阅读 评论(0) 收藏 举报
分类：
作者同类文章 X

    版权声明：本文为博主原创文章，未经博主允许不得转载。

    在caffe中摸爬滚打了一个多月了，修改caffe源代码，早就想练练手了，loss层是一个比较独立的一个层，而且可以仿照caffe给的样例进行添加，难度会稍微小点。caffe自带了十种loss层(contrastive、euclidean、hinge、multinomial_logistic、sigmoid_cross_entropy、smooth_L1、smooth_L1_ohem、softmax、softmax_ohem、infogain)

    详细见：http://blog.csdn.net/sihailongwang/article/details/72657637

    公式含义推荐：http://blog.csdn.net/u012177034/article/details/52144325

    接下来，就是自己添加一个新的loss(层)函数了，我打算添加：Absolute loss

    第一步：在caffe.proto增加对应的LayerParameter message

    [plain] view plain copy
    print ?
    1. optional AbsoluteLossParameter Absolute_loss_param = 151;  
    optional AbsoluteLossParameter Absolute_loss_param = 151;

    [plain] view plain copy
    print ?
    1. message AbsoluteLossParameter   
    2. {  
    3.   optional float dis = 1 [default = 1];  
    4. }  
    message AbsoluteLossParameter 
{
  optional float dis = 1 [default = 1];
}

    第二步：在./include/caffe/layers/下增加相应的layer的声明

    [plain] view plain copy
    print ?
    1. #ifndef CAFFE_ABSOLUTE_LOSS_LAYER_HPP_  
    2. #define CAFFE_ABSOLUTE_LOSS_LAYER_HPP_  
    3.   
    4.   
    5. #include <vector>  
    6.   
    7.   
    8. #include "caffe/blob.hpp"  
    9. #include "caffe/layer.hpp"  
    10. #include "caffe/proto/caffe.pb.h"  
    11.   
    12.   
    13. #include "caffe/layers/loss_layer.hpp"  
    14.   
    15.   
    16. namespace caffe {  
    17.   
    18.   
    19. template <typename Dtype>  
    20. class AbsoluteLossLayer : public LossLayer<Dtype> {  
    21.  public:  
    22.   explicit AbsoluteLossLayer(const LayerParameter& param)  
    23.       : LossLayer<Dtype>(param), dis_() {}  
    24.   virtual void Reshape(const vector<Blob<Dtype>*>& bottom,  
    25.       const vector<Blob<Dtype>*>& top);  
    26.   
    27.   
    28.   virtual inline const char* type() const { return "AbsoluteLoss"; }  
    29.   
    30.   
    31.   virtual inline bool AllowForceBackward(const int bottom_index) const {  
    32.     return true;  
    33.   }  
    34.   
    35.   
    36.  protected:  
    37.   /// @copydoc AbsoluteLossLayer  
    38.   virtual void Forward_cpu(const vector<Blob<Dtype>*>& bottom,  
    39.       const vector<Blob<Dtype>*>& top);  
    40.   virtual void Forward_gpu(const vector<Blob<Dtype>*>& bottom,  
    41.       const vector<Blob<Dtype>*>& top);  
    42.   
    43.   
    44.   virtual void Backward_cpu(const vector<Blob<Dtype>*>& top,  
    45.       const vector<bool>& propagate_down, const vector<Blob<Dtype>*>& bottom);  
    46.   virtual void Backward_gpu(const vector<Blob<Dtype>*>& top,  
    47.       const vector<bool>& propagate_down, const vector<Blob<Dtype>*>& bottom);  
    48.   
    49.   
    50.   Blob<Dtype> dis_;  
    51. };  
    52.   
    53.   
    54. }  // namespace caffe  
    55.   
    56.   
    57. #endif  // CAFFE_EUCLIDEAN_LOSS_LAYER_HPP_  
    58.   
    59. #endif  // CAFFE_EUCLIDEAN_LOSS_LAYER_HPP_  
    #ifndef CAFFE_ABSOLUTE_LOSS_LAYER_HPP_
#define CAFFE_ABSOLUTE_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"


namespace caffe {


template <typename Dtype>
class AbsoluteLossLayer : public LossLayer<Dtype> {
 public:
  explicit AbsoluteLossLayer(const LayerParameter& param)
      : LossLayer<Dtype>(param), dis_() {}
  virtual void Reshape(const vector<Blob<Dtype>*>& bottom,
      const vector<Blob<Dtype>*>& top);


  virtual inline const char* type() const { return "AbsoluteLoss"; }


  virtual inline bool AllowForceBackward(const int bottom_index) const {
    return true;
  }


 protected:
  /// @copydoc AbsoluteLossLayer
  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);


  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);


  Blob<Dtype> dis_;
};


}  // namespace caffe


#endif  // CAFFE_EUCLIDEAN_LOSS_LAYER_HPP_

#endif  // CAFFE_EUCLIDEAN_LOSS_LAYER_HPP_

    第三步：在./src/caffe/util/math_functions.cpp/下增加“绝对值求和”模板函数

    说明：因为AbsoluteLoss需要绝对值求和，所以在math_fuction.cpp中需要增加一个“绝对值”模板函数（与此同时，我惊喜的发现了BLAS、CBLAS）

    /********************************************************************************************************************

    TIPS：科普一下什么是BLAS/CBLAS

    Basic Linear Algebra Subprograms，即基础线性代数子程序库，里边拥有大量的已经编好的关于线性代数运算的程序，主要用于向量和矩阵的计算的高性能数学库，本身是由Fortran编写的，为了方便C/C++程序使用，就有了BLAS的C接口库CBLAS，详细列表：http://www.netlib.org/blas/

    /********************************************************************************************************************

    [plain] view plain copy
    print ?
    1. //--------------------------add------------------------------------------  
    2. template <>  
    3. float caffe_cpu_asum<float>(const int n, const float* x) {  
    4.   return cblas_sasum(n, x, 1);      //sum of absolute values  
    5. }  
    6.   
    7. template <>  
    8. double caffe_cpu_asum<double>(const int n, const double* x) {  
    9.   return cblas_dasum(n, x, 1);      //sum of absolute values  
    10. }  
    11.   
    12. template <typename Dtype>  
    13. Dtype caffe_cpu_abs_sum(const int n, const Dtype* x) {  
    14.   return caffe_cpu_asum(n, x);  
    15. }  
    16.   
    17. template  
    18. float caffe_cpu_asum<float>(const int n, const float* x);  
    19.   
    20. template  
    21. double caffe_cpu_asum<double>(const int n, const double* x);  
    22. //-------------------------add-------------------------------------------  
    //--------------------------add------------------------------------------
template <>
float caffe_cpu_asum<float>(const int n, const float* x) {
  return cblas_sasum(n, x, 1);      //sum of absolute values
}

template <>
double caffe_cpu_asum<double>(const int n, const double* x) {
  return cblas_dasum(n, x, 1);      //sum of absolute values
}

template <typename Dtype>
Dtype caffe_cpu_abs_sum(const int n, const Dtype* x) {
  return caffe_cpu_asum(n, x);
}

template
float caffe_cpu_asum<float>(const int n, const float* x);

template
double caffe_cpu_asum<double>(const int n, const double* x);
//-------------------------add-------------------------------------------

    第四步：在./src/caffe/layers/下增加相应layer的CPU/GPU实现文件

       CPU版本（absolute_loss_layer.cpp）：

    [plain] view plain copy
    print ?
    1. #include <vector>  
    2.   
    3. #include "caffe/layers/absolute_loss_layer.hpp"  
    4. #include "caffe/util/math_functions.hpp"  
    5.   
    6. namespace caffe {  
    7.   
    8. template <typename Dtype>  
    9. void AbsoluteLossLayer<Dtype>::Reshape(  
    10.   const vector<Blob<Dtype>*>& bottom, const vector<Blob<Dtype>*>& top) {  
    11.   LossLayer<Dtype>::Reshape(bottom, top);   //在LossLayer 中定义  
    12.   CHECK_EQ(bottom[0]->count(1), bottom[1]->count(1))  //保证输入维度相同  
    13.       << "Inputs must have the same dimension.";  
    14.   dis_.ReshapeLike(*bottom[0]);           //Blob 类型的diff_用来存放两个bottom的差，和bottom具有相同的  
    15. }  
    16.   
    17. template <typename Dtype>  
    18. void AbsoluteLossLayer<Dtype>::Forward_cpu(const vector<Blob<Dtype>*>& bottom,  
    19.     const vector<Blob<Dtype>*>& top) {  
    20.   int count = bottom[0]->count();   //总共有count个featuremap   
    21.   caffe_sub(  
    22.       count,  
    23.       bottom[0]->cpu_data(),  
    24.       bottom[1]->cpu_data(),  
    25.       dis_.mutable_cpu_data());    //diff_ = bottom[0] - bottom[1]   
    26.   Dtype loss_param = this->layer_param_.absolute_loss_param().dis();  
    27.   Dtype abs_sum = caffe_cpu_abs_sum(count,dis_.cpu_data());  
    28.   //Dtype dot = caffe_cpu_abs_sum()(count, diff_.cpu_data(), dis_.cpu_data());  
    29.   Dtype loss = loss_param * abs_sum / bottom[0]->num();  
    30.   top[0]->mutable_cpu_data()[0] = loss;  
    31. }  
    32.   
    33. template <typename Dtype>  
    34. void AbsoluteLossLayer<Dtype>::Backward_cpu(const vector<Blob<Dtype>*>& top,  
    35.     const vector<bool>& propagate_down, const vector<Blob<Dtype>*>& bottom) {  
    36.   for (int i = 0; i < 2; ++i) {  
    37.     if (propagate_down[i]) {  
    38.        //对于输入的label bottom propagate_dowm为0  
    39.       const Dtype sign = (i == 0) ? 1 : -1;  
    40.       const Dtype alpha = sign * top[0]->cpu_diff()[0] / bottom[i]->num();  
    41.       caffe_cpu_axpby(  
    42.           bottom[i]->count(),                       // count  
    43.           alpha,                             // alpha  
    44.           dis_.cpu_data(),                        // a  
    45.           Dtype(0),                           // beta  
    46.           bottom[i]->mutable_cpu_diff());                 // b  
    47.     }     //bottom[i]->mutable_cpu_diff()) = alpha*dis_.cpu_data()  
    48.   }  
    49. }  
    50.   
    51. #ifdef CPU_ONLY  
    52. STUB_GPU(AbsoluteLossLayer);  
    53. #endif  
    54.   
    55. INSTANTIATE_CLASS(AbsoluteLossLayer);  
    56. REGISTER_LAYER_CLASS(AbsoluteLoss);  
    57.   
    58. }  // namespace caffe  
    #include <vector>

#include "caffe/layers/absolute_loss_layer.hpp"
#include "caffe/util/math_functions.hpp"

namespace caffe {

template <typename Dtype>
void AbsoluteLossLayer<Dtype>::Reshape(
  const vector<Blob<Dtype>*>& bottom, const vector<Blob<Dtype>*>& top) {
  LossLayer<Dtype>::Reshape(bottom, top);   //在LossLayer 中定义
  CHECK_EQ(bottom[0]->count(1), bottom[1]->count(1))  //保证输入维度相同
      << "Inputs must have the same dimension.";
  dis_.ReshapeLike(*bottom[0]);           //Blob 类型的diff_用来存放两个bottom的差，和bottom具有相同的
}

template <typename Dtype>
void AbsoluteLossLayer<Dtype>::Forward_cpu(const vector<Blob<Dtype>*>& bottom,
    const vector<Blob<Dtype>*>& top) {
  int count = bottom[0]->count();   //总共有count个featuremap 
  caffe_sub(
      count,
      bottom[0]->cpu_data(),
      bottom[1]->cpu_data(),
      dis_.mutable_cpu_data());    //diff_ = bottom[0] - bottom[1] 
  Dtype loss_param = this->layer_param_.absolute_loss_param().dis();
  Dtype abs_sum = caffe_cpu_abs_sum(count,dis_.cpu_data());
  //Dtype dot = caffe_cpu_abs_sum()(count, diff_.cpu_data(), dis_.cpu_data());
  Dtype loss = loss_param * abs_sum / bottom[0]->num();
  top[0]->mutable_cpu_data()[0] = loss;
}

template <typename Dtype>
void AbsoluteLossLayer<Dtype>::Backward_cpu(const vector<Blob<Dtype>*>& top,
    const vector<bool>& propagate_down, const vector<Blob<Dtype>*>& bottom) {
  for (int i = 0; i < 2; ++i) {
    if (propagate_down[i]) {
       //对于输入的label bottom propagate_dowm为0
      const Dtype sign = (i == 0) ? 1 : -1;
      const Dtype alpha = sign * top[0]->cpu_diff()[0] / bottom[i]->num();
      caffe_cpu_axpby(
          bottom[i]->count(),                       // count
          alpha,                             // alpha
          dis_.cpu_data(),                        // a
          Dtype(0),                           // beta
          bottom[i]->mutable_cpu_diff());                 // b
    }     //bottom[i]->mutable_cpu_diff()) = alpha*dis_.cpu_data()
  }
}

#ifdef CPU_ONLY
STUB_GPU(AbsoluteLossLayer);
#endif

INSTANTIATE_CLASS(AbsoluteLossLayer);
REGISTER_LAYER_CLASS(AbsoluteLoss);

}  // namespace caffe
    GPU版本（absolute_loss_layer.cu）：
    [plain] view plain copy
    print ?
    1. #include <vector>  
    2.   
    3.   
    4. #include "caffe/layers/absolute_loss_layer.hpp"  
    5. #include "caffe/util/math_functions.hpp"  
    6.   
    7. namespace caffe {  
    8.   
    9. template <typename Dtype>  
    10. void AbsoluteLossLayer<Dtype>::Forward_gpu(const vector<Blob<Dtype>*>& bottom,  
    11.     const vector<Blob<Dtype>*>& top) {  
    12.   int count = bottom[0]->count();   //总共有count个featuremap   
    13.   caffe_gpu_sub(  
    14.       count,  
    15.       bottom[0]->gpu_data(),  
    16.       bottom[1]->gpu_data(),  
    17.       dis_.mutable_gpu_data());  
    18.   Dtype loss_param = this->layer_param_.  
    19.   Dtype abs_sum;  
    20.   caffe_gpu_asum(count, dis_.gpu_data(), &abs_sum);  
    21.   Dtype loss = loss_param * abs_sum/ bottom[0]->num();  
    22.   top[0]->mutable_cpu_data()[0] = loss;  
    23. }  
    #include <vector>


#include "caffe/layers/absolute_loss_layer.hpp"
#include "caffe/util/math_functions.hpp"

namespace caffe {

template <typename Dtype>
void AbsoluteLossLayer<Dtype>::Forward_gpu(const vector<Blob<Dtype>*>& bottom,
    const vector<Blob<Dtype>*>& top) {
  int count = bottom[0]->count();   //总共有count个featuremap 
  caffe_gpu_sub(
      count,
      bottom[0]->gpu_data(),
      bottom[1]->gpu_data(),
      dis_.mutable_gpu_data());
  Dtype loss_param = this->layer_param_.
  Dtype abs_sum;
  caffe_gpu_asum(count, dis_.gpu_data(), &abs_sum);
  Dtype loss = loss_param * abs_sum/ bottom[0]->num();
  top[0]->mutable_cpu_data()[0] = loss;
}
    [plain] view plain copy
    print ?
    1. template <typename Dtype>  
    2. void AbsoluteLossLayer<Dtype>::Backward_gpu(const vector<Blob<Dtype>*>& top,  
    3.     const vector<bool>& propagate_down, const vector<Blob<Dtype>*>& bottom) {  
    4.   for (int i = 0; i < 2; ++i) {  
    5.     if (propagate_down[i]) {  
    6.       const Dtype sign = (i == 0) ? 1 : -1;  
    7.       const Dtype alpha = sign * top[0]->cpu_diff()[0] / bottom[i]->num();  
    8.       caffe_gpu_axpby(  
    9.           bottom[i]->count(),                       // count  
    10.           alpha,                             // alpha  
    11.           dis_.gpu_data(),                        // a  
    12.           Dtype(0),                           // beta  
    13.           bottom[i]->mutable_gpu_diff());                 // b  
    14.     }  
    15.   }  
    16. }  
    17.   
    18. INSTANTIATE_LAYER_GPU_FUNCS(AbsoluteLossLayer);  
    19.   
    20. }  // namespace caffe  
    template <typename Dtype>
void AbsoluteLossLayer<Dtype>::Backward_gpu(const vector<Blob<Dtype>*>& top,
    const vector<bool>& propagate_down, const vector<Blob<Dtype>*>& bottom) {
  for (int i = 0; i < 2; ++i) {
    if (propagate_down[i]) {
      const Dtype sign = (i == 0) ? 1 : -1;
      const Dtype alpha = sign * top[0]->cpu_diff()[0] / bottom[i]->num();
      caffe_gpu_axpby(
          bottom[i]->count(),                       // count
          alpha,                             // alpha
          dis_.gpu_data(),                        // a
          Dtype(0),                           // beta
          bottom[i]->mutable_gpu_diff());                 // b
    }
  }
}

INSTANTIATE_LAYER_GPU_FUNCS(AbsoluteLossLayer);

}  // namespace caffe

    第五步：用vs打开caffe，进行编译，编译成功后，恭喜你，功力又上升一个段位，哈哈

    1.修改../windows/libcaffe下的两个文件：libcaffe.vcxproj和libcaffe.vcxproj.filters

    libcaffe.vcxproj增加：

    [plain] view plain copy
    print ?
    1. <ClCompile Include="..\..\src\caffe\layers\absolute_loss_layer.cpp" />  
    2. <ClInclude Include="..\..\include\caffe\layers\absolute_loss_layer.hpp" />  
    3. <CudaCompile Include="..\..\src\caffe\layers\absolute_loss_layer.cu" />  
    <ClCompile Include="..\..\src\caffe\layers\absolute_loss_layer.cpp" />
<ClInclude Include="..\..\include\caffe\layers\absolute_loss_layer.hpp" />
<CudaCompile Include="..\..\src\caffe\layers\absolute_loss_layer.cu" />
    libcaffe.vcxproj.filter增加：
    [plain] view plain copy
    print ?
    1. <ClInclude Include="..\..\include\caffe\layers\absolute_loss_layer.hpp">  
    2. <Filter>include\layers</Filter>  
    3. </ClInclude>  
    4. <CudaCompile Include="..\..\src\caffe\layers\absolute_loss_layer.cu">  
    5. <Filter>cu\layers</Filter>  
    6. </CudaCompile>  
    7. <ClCompile Include="..\..\src\caffe\layers\absolute_loss_layer.cpp">  
    8. <Filter>src\layers</Filter>  
    9. </ClCompile>  
    <ClInclude Include="..\..\include\caffe\layers\absolute_loss_layer.hpp">
<Filter>include\layers</Filter>
</ClInclude>
<CudaCompile Include="..\..\src\caffe\layers\absolute_loss_layer.cu">
<Filter>cu\layers</Filter>
</CudaCompile>
<ClCompile Include="..\..\src\caffe\layers\absolute_loss_layer.cpp">
<Filter>src\layers</Filter>
</ClCompile>
    2.打开caffe.sln，再进行重新生成新的解决方案，编译通过后，恭喜你功力又升一级！
    顶
    0
    踩
    0
     
     
      相关文章推荐
    ShenBoosting
    关注
    • 0
      点赞
    • 踩
    • 0
      收藏
      觉得还不错? 一键收藏
    • 0
      评论
    专栏目录
    OHEM算法及Caffe代码详解
    AI之路
    06-12 1万+
    这是CVPR2016的一篇论文，用于目标检测，本篇博文先介绍这个算法，然后介绍其Caffe代码。论文：Training Region-based Object Detectors with Online Hard Example Mining 论文链接：https://arxiv.org/abs/1604.03540算法概述：OHEM（online hard example miniing）算法的
    修改caffe源代码--添加loss(层)函数--CPU
    风哥有点田
    08-31 2978
    本文主体参考：http://blog.csdn.net/sihailongwang/article/details/72783944 因其在windows上面操作，本文提供在linux上操作的尝试。另外部分命名不规则，所以修正了一下。 修改caffe源代码，loss层是一个比较独立的一个层，而且可以仿照caffe给的样例进行添加，难度会稍微小点。 caffe自带了十种loss层(
    DeepLearning（基于caffe）实战项目（8）--修改caffe源代码从添加loss(层)函数开始
    龙王Black的博客
    05-27 4272
    在caffe中摸爬滚打了一个多月了，修改caffe源代码，早就想练练手了，loss层是一个比较独立的一个层，而且可以仿照caffe给的样例进行添加，难度会稍微小点。
    caffe 自定义层/添加自己的损失函数
    机器学习的小学生
    03-12 9618
    自定义激活层文献[2] 以循序渐进的学习方式先后介绍了： google protocol buffe , Blob ,SyncedMemory ,shared_ptr ,layer,data layer 然后利用这些知识来自定义一个层。其给出的例子是定义一个power层，可以通过caffe的api参考其结构：http://caffe.berkeleyvision.org/doxygen/cla
    py-R-FCN源码分析
    Marshall的专栏
    01-05 6744
    softmax_loss_ohem_layer.cu #include #include #include #include "caffe/layers/softmax_loss_ohem_layer.hpp" #include "caffe/util/math_functions.hpp" namespace caffe { template __global__ void
    windows下安装caffe_ssd并添加centor_loss层
    03-22
    首先，你需要从GitHub上下载Windows版本的Caffe-SSD源代码。推荐从链接<https://github.com/conner99/caffe>的ssd-microsoft分支获取。这个版本是专门为Windows环境优化的，并且包含了用于目标检测的Single Shot ...
    Caffe 代码粗解
    09-14
    Caffe的数据层设计灵活，支持多种数据源，如ImageDataLayer用于处理图像，MemoryDataLayer用于在内存中传递数据，或者HDF5DataLayer用于读取HDF5格式的大数据集。每个数据层都包含一个预处理步骤，可以进行归一化、...
    caffe-master.zip
    07-14
    在2019年7月13日的这个版本中，我们可以深入探索Caffe的源代码，了解其设计思想和实现细节。 Caffe的核心特点在于其速度和灵活性。它的设计哲学是“速度第一，简洁第二”，使得模型训练和推断过程快速且资源效率高...
    caffe的组织结构1
    最新发布
    08-08
    本文将深入探讨 Caffe 的数据组织结构和层（Layer）的组织结构，这对于理解和使用 Caffe 进行深度学习训练至关重要。 首先，让我们关注数据组织部分。在 Caffe 中，数据通常存储在 LevelDB 或 LMDB 数据库中。LMDB ...
    yolov5_caffe-源码
    09-04
    在`yolov5_caffe-master`这个压缩包中，很可能包含了完整的源代码和必要的配置文件，用于将YOLOv5模型转换为Caffe格式。开发者可能需要按照以下步骤操作： 1. **预处理**: 首先，需要将YOLOv5的PyTorch权重转换为...
    caffe 加权交叉熵损失函数 SigmoidCrossEntropyLoss
    12-24
    论文中"Holistically-Nested Edge Detection"使用的加权损失函数，具体用法见博客http://blog.csdn.net/majinlei121/article/details/78884531
    论文笔记 OHEM: Training Region-based Object Detectors with Online Hard Example Mining
    热门推荐
    xiaoxiang_AQ 的博客
    10-08 2万+
    CVPR2016的文章，CMU与rbg大神的合作。原谅我一直没有对这篇文章做一个笔记~~ 文章提出了一种通过online hard example mining（OHEM）算法训练基于区域的卷积检测算子的高效目标检测算法，能够对简单样本和一些小数量样本进行抑制，使得训练过程更加高效。该方法利用显著的bootstrapping技术（SVM中被普遍利用），对SGD算法进行一定的修改，使得原有的reg
    caffe添加自定义loss层
    qq_34867559的博客
    05-23 2170
    caffe添加自定义loss层 复现MTCNN，需要修改loss层，基于EuclideanLoss，： 修改forward部分，实现分类别训练（ground truth为-1时，loss为0） 修改backward部分，实现在线难例挖掘（还没做，以后补） 参考Github上的代码，他实现了gpu版本，我在此实现cpu版本 用VS打开工程 caffe-windows/scripts/...
    Caffe添加自定义层-自定义loss
    Mr.Lei
    09-24 1586
    Caffe添加自定义层-如何自定义loss层
    Caffe解惑：Caffe中是如何控制loss的
    一亩半分地
    04-18 9420
    caffe是使用loss_weight控制loss的传递 在基本类Layer里的函数如下 对于loss Layer loss_weight非0，对于非loss Layer，loss_weight都是0 所以Layer对网络loss的贡献值也为0
    caffe-windows添加自己的loss层
    qq_33468806的博客
    04-01 2457
    最近几天忙着在添加center loss层，因为是在windows系统下，所以参考了很多的博客，发现都是在linux下的，遇到很多问题，这里和大家分享自己的经历，希望对大家有个帮助，也对在windows下跑着caffe和我一样的菜鸟帮助。另外，如果只是添加center loss（cvpr2015）或者triple loss（cvpr2015）年，我建议配置happynear大神的最新版caffe（
    论文阅读学习 - Center Loss: Caffe 实现
    长风破浪会有时，直挂云帆济沧海
    11-16 2425
    Center Loss - Caffe实现
    Caffe 源码的修改（用于车辆的定位）（多标签）
    xk_snail的专栏
    03-10 538
    http://blog.csdn.net/baobei0112/article/details/47606559
    原始caffe添加CenterLoss_layer
    samylee的博客
    08-03 3155
    CenterLoss_layer可以在原分类的基础上（某种程度上）可提升几个点左右（博主测试提升6个点），还不占前向时间，好东西啊！ 原理这里不介绍了，网上应有尽有！这里只是介绍如何在caffe中如何添加CenterLoss_layer这样的新层！
    Caffe网络模型深度解析：数据层详解
    "这篇文档详细介绍了Caffe网络模型中的数据层，主要内容包括数据层的作用、参数配置以及数据来源。" 在Caffe深度学习框架中，网络模型是由多个层（layer）组成的，每个层都有特定的功能，并通过Blobs进行数据传递。...
    评论
    添加红包

    请填写红包祝福语或标题

    个

    红包个数最小为10个

    元

    红包金额最低5元

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

    抵扣说明：

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

    余额充值