添加新Layer -caffe （绝对值损失，SmoothL1损失）

最新推荐文章于 2018-08-23 11:11:38 发布
最新推荐文章于 2018-08-23 11:11:38 发布
阅读量877 收藏
点赞数
分类专栏： 深度学习框架 caffe
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011808673/article/details/80758981
版权

1.RoiPoolingLayer 

2.SmoothL1LossLayer

caffe 的 Fast_Rcnn 实现， 里面包含 RoiPoolingLayer  和 SmoothL1LossLayer

https://github.com/rbgirshick/caffe-fast-rcnn/

注意： 把编译改成 61 否者 cu文件无法编译成功

 

想要在现有的caffe版本添加ROIPoolingLayer 和SmoothL1LossLayer，首先到这里https://github.com/rbgirshick/caffe-fast-rcnn可以找到他们的定义。caffe添加layer的详细方法在这里可以看到https://github.com/BVLC/caffe/wiki/，然后我们就可以开始啦！！

1.ROIPoolingLayer 和SmoothL1LossLayer的声明与实现：

声明：caffe_root/include/caffe/fast_rcnn_layers.hpp

实现：caffe_root/src/caffe/layers/roi_pooling_layer.cpp

    caffe_root/src/caffe/layers/roi_pooling_layer.cu

    caffe_root/src/caffe/layers/smooth_L1_loss_layer.cpp

    caffe_root/src/caffe/layers/smooth_L1_loss_layer.cu

2.ROIPoolingLayer 和SmoothL1LossLayer的测试：

caffe_root/src/caffe/test/test_roi_pooling_layer.cpp

caffe_root/src/caffe/test/test_smooth_L1_loss_layer.cpp

 

上面的整体过程是没有问题的，但是在 实现的时候 SmoothL1有个方法 LayerSetUp 在实现时没有调用父类方法，所以导致梯度反向传播时权重以直为0 无法更新，下面的代码已修改该问题。

 

3.注册

caffe_root/src/caffe/proto/caffe.proto添加

optional ROIPoolingParameter roi_pooling_param = 8266711;



// Message that stores parameters used by ROIPoolingLayer
message ROIPoolingParameter {
// Pad, kernel size, and stride are all given as a single value for equal
// dimensions in height and width or as Y, X pairs.
  optional uint32 pooled_h = 1 [default = 0]; // The pooled output height
  optional uint32 pooled_w = 2 [default = 0]; // The pooled output width
  // Multiplicative spatial scale factor to translate ROI coords from their
  // input scale to the scale used when pooling
  optional float spatial_scale = 3 [default = 1];
}

optional SmoothL1LossParameter smooth_l1_loss_param = 8266712;

message SmoothL1LossParameter {
  // SmoothL1Loss(x) =
  //   0.5 * (sigma * x) ** 2    -- if x < 1.0 / sigma / sigma
  //   |x| - 0.5 / sigma / sigma -- otherwise
  optional float sigma = 1 [default = 1];
}

完成







caffe  添加 smooth

smooth_L1_loss_layer.hpp

#ifndef CAFFE_SMOOTH_L1_LOSS_LAYER_HPP_
#define CAFFE_SMOOTH_L1_LOSS_LAYER_HPP_


#include <vector>


#include "caffe/blob.hpp"
#include "caffe/common.hpp"
#include "caffe/layer.hpp"
#include "caffe/proto/caffe.pb.h"


#include "caffe/layers/loss_layer.hpp"


namespace caffe {




	template <typename Dtype>
	class SmoothL1LossLayer : public LossLayer<Dtype> {
	public:
		explicit SmoothL1LossLayer(const LayerParameter& param)
			: LossLayer<Dtype>(param), diff_() {}
		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 "SmoothL1Loss"; }


		//virtual inline int ExactNumBottomBlobs() const { return -1; }
		//virtual inline int MinBottomBlobs() const { return 2; }
		//virtual inline int MaxBottomBlobs() const { return 4; }


		/**
		 * Unlike most loss layers, in the SmoothL1LossLayer we can backpropagate
		 * to both inputs -- override to return true and always allow force_backward.
		 */
		virtual inline bool AllowForceBackward(const int bottom_index) const {
			return true;
		}


	protected:
		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> diff_;
		Blob<Dtype> errors_;
		Blob<Dtype> ones_;
		bool has_weights_;
		Dtype sigma2_;
	};


}  // namespace caffe


#endif  // CAFFE_FAST_RCNN_LAYERS_HPP_



smooth_L1_loss_layer.cpp



#include <vector>


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


namespace caffe {


	template <typename Dtype>
	void SmoothL1LossLayer<Dtype>::LayerSetUp(
		const vector<Blob<Dtype>*>& bottom, const vector<Blob<Dtype>*>& top) {
		LossLayer<Dtype>::LayerSetUp(bottom, top);
		SmoothL1LossParameter loss_param = this->layer_param_.smooth_l1_loss_param();
		sigma2_ = loss_param.sigma() * loss_param.sigma();
		has_weights_ = (bottom.size() >= 3);
		if (has_weights_) {
			CHECK_EQ(bottom.size(), 4) << "If weights are used, must specify both "
				"inside and outside weights";
		}
	}


	template <typename Dtype>
	void SmoothL1LossLayer<Dtype>::Reshape(
		const vector<Blob<Dtype>*>& bottom, const vector<Blob<Dtype>*>& top) {
		LossLayer<Dtype>::Reshape(bottom, top);
		CHECK_EQ(bottom[0]->channels(), bottom[1]->channels());
		CHECK_EQ(bottom[0]->height(), bottom[1]->height());
		CHECK_EQ(bottom[0]->width(), bottom[1]->width());
		if (has_weights_) {
			CHECK_EQ(bottom[0]->channels(), bottom[2]->channels());
			CHECK_EQ(bottom[0]->height(), bottom[2]->height());
			CHECK_EQ(bottom[0]->width(), bottom[2]->width());
			CHECK_EQ(bottom[0]->channels(), bottom[3]->channels());
			CHECK_EQ(bottom[0]->height(), bottom[3]->height());
			CHECK_EQ(bottom[0]->width(), bottom[3]->width());
		}
		diff_.Reshape(bottom[0]->num(), bottom[0]->channels(),
			bottom[0]->height(), bottom[0]->width());
		errors_.Reshape(bottom[0]->num(), bottom[0]->channels(),
			bottom[0]->height(), bottom[0]->width());
		// vector of ones used to sum
		ones_.Reshape(bottom[0]->num(), bottom[0]->channels(),
			bottom[0]->height(), bottom[0]->width());
		for (int i = 0; i < bottom[0]->count(); ++i) {
			ones_.mutable_cpu_data()[i] = Dtype(1);
		}
	}


	template <typename Dtype>
	void SmoothL1LossLayer<Dtype>::Forward_cpu(const vector<Blob<Dtype>*>& bottom,
		const vector<Blob<Dtype>*>& top) {
		// cpu implementation
		CHECK_EQ(bottom[0]->count(1), bottom[1]->count(1))
			<< "Inputs must have the same dimension.";
		int count = bottom[0]->count();
		caffe_sub(count,
			bottom[0]->cpu_data(),
			bottom[1]->cpu_data(),
			diff_.mutable_cpu_data());


		if (has_weights_) {
			caffe_mul(count,
				bottom[2]->cpu_data(),
				diff_.cpu_data(),
				diff_.mutable_cpu_data());
		}
		// f(x) = 0.5 * (sigma * x)^2          if |x| < 1 / sigma / sigma
		//        |x| - 0.5 / sigma / sigma    otherwise
		const Dtype* in = diff_.cpu_data();
		Dtype* out = errors_.mutable_cpu_data();
		for (int index = 0; index<count; ++index) {
			Dtype val = in[index];
			Dtype abs_val = abs(val);
			if (abs_val < 1.0 / sigma2_) {
				out[index] = 0.5 * val * val * sigma2_;
			}
			else {
				out[index] = abs_val - 0.5 / sigma2_;
			}
		}


		if (has_weights_) {
			caffe_mul(count, bottom[3]->cpu_data(), out, errors_.mutable_cpu_data());
		}


		// compute loss
		Dtype loss = caffe_cpu_dot(count, ones_.cpu_data(), errors_.cpu_data());
		top[0]->mutable_cpu_data()[0] = loss / bottom[0]->num();
		// end cpu implementation
	}


	template <typename Dtype>
	void SmoothL1LossLayer<Dtype>::Backward_cpu(const vector<Blob<Dtype>*>& top,
		const vector<bool>& propagate_down, const vector<Blob<Dtype>*>& bottom) {


		// cpu implementation
		int count = diff_.count();
		const Dtype* in = diff_.cpu_data();
		Dtype* out = diff_.mutable_cpu_data();
		for (int index = 0; index < count; index++) {
			Dtype val = in[index];
			Dtype abs_val = abs(val);
			if (abs_val < 1.0 / sigma2_) {
				out[index] = sigma2_ *  val;
			}
			else {
                                //cool val > 0时 out = 1, val < 0 时 out = -1, val = 0时  out== 0  对 |x|求梯度
				out[index] = (Dtype(0) < val) - (val < Dtype(0));
			}
		}


		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_cpu_axpby(
					count,
					alpha,
					out,//diff_.cpu_data(), 
					Dtype(0),
					bottom[i]->mutable_cpu_diff());


				if (has_weights_) {
					caffe_mul(
						count,
						bottom[2]->cpu_data(),
						bottom[i]->cpu_diff(),
						bottom[i]->mutable_cpu_data());
					caffe_mul(
						count,
						bottom[3]->cpu_data(),
						bottom[i]->cpu_diff(),
						bottom[i]->mutable_cpu_data());
				}
			}
		}
		// end cpu implementation
	}


#ifdef CPU_ONLY
	STUB_GPU(SmoothL1LossLayer);
#endif


	INSTANTIATE_CLASS(SmoothL1LossLayer);
	REGISTER_LAYER_CLASS(SmoothL1Loss);


}  // namespace caffe

 

 

 

注册：

注意  SmoothL1Loss 最好与 virtual inline const char* type() const { return "SmoothL1Loss"; } 的返回  保持一致

optional SmoothL1LossParameter smooth_l1_loss_param = 152;

message SmoothL1LossParameter {
  optional float sigma = 1 [default = 1];
}

 

 

 

添加 absolute_loss_layer

1.注册

message AbsoluteLossParameter
{
  optional float dis = 1 [default = 1];
} 
optional AbsoluteLossParameter Absolute_loss_param = 151;
//*****************************************
#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_  

#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) { 
	int count = bottom[0]->count();
	Dtype * dis_value = dis_.mutable_cpu_data();
	for (int i = 0; i < count; i++)
	{
		dis_value[i] = (Dtype(0) < dis_value[i]) - (dis_value[i] < Dtype(0));
		//替换方案 表达一致 
		//if (dis_value[i] > 0)
		//{
		//	dis_value[i] = 1;
		//}
		//else if(dis_value[i] < 0)
		//{
		//	dis_value[i] = -1;
		//}
		//else
		//{
		//	dis_value[i] = 0;
		//}
	}
  for (int i = 0; i < 2; ++i) {  
    if (propagate_down[i]) {  
       //对于输入的label bottom propagate_dowm为0
	  //LOG_IF(INFO, Caffe::root_solver()) << "use cpu code ................ i is:" << i;
      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

 

 

 

NineDays66
关注
专栏目录
waifu2x-caffe.zip
04-28
7. waifu2x-caffe-cui.exe：这是命令行版本的waifu2x-caffe，对于喜欢命令行操作或者需要自动化处理大量图像的用户来说非常实用。 8. LICENSE.txt：这是waifu2x-caffe的授权协议文件，通常包含了软件的使用条款和...
关于caffe-ssd训练时smooth_L1到底参与运算与否的问题
maum61的专栏
08-20 310
最近在研究SSD的源码，惊讶的发现，在https://github.com/weiliu89/caffe/tree/ssd 上给出的源码，与论文中描述竟然不一样！或许是我错了。下面给出疑问和证据。 疑问：mbox_loss中到底包含没包含loc_loss? smooth_L1到底参与运算了没？ 首先，在生成脚本：ssd_pascal.py中mining_type是:MAX_NEGATIV...
Caffe Smooth_L1_Loss_Layer 问答
MaybePossible
01-03 2323
问：参数中设置sigma原因是什么？rbg答：As sigma -> inf the loss approaches L1 (abs) loss. Setting sigma = 3, makes the transition point from quadratic to linear happen at |x| <= 1 / 3**2 (closer to the origin). The re
SSD网络解析之SmoothL1LossLayer层
qq_21368481的博客
08-23 3096
SSD网络中的SmoothL1LossLayer层借鉴于Fast R-CNN，用于计算smooth L1损失，其中的光滑L1函数如下：                                                                其导函数为：                                                           ...
深度学习: smooth L1 loss 计算
湛蓝的天空
05-03 8843
RPN的目标函数是分类和回归损失的和，分类采用 交叉熵，回归采用稳定的 Smooth L1， SmoothL1公式 为： 整体损失函数 具体为： [1] Faster R-CNN原理介绍  [2] 深度网络中softmax_loss、Smooth L1 loss计算以及反向传播推导
faster rcnn的源码理解（一）SmoothL1LossLayer论文与代码的结合理解
野孩子的专栏
05-19 1万+
源码： // ------------------------------------------------------------------ // Fast R-CNN // Copyright (c) 2015 Microsoft // Licensed under The MIT License [see fast-rcnn/LICENSE for details] // Writte
imagenet-caffe-alex.mat
01-15
《深度学习模型与数据集：理解“imagenet-caffe-alex.mat”》 在计算机视觉领域，深度学习模型已经成为图像分类、识别和检测任务的核心工具。本文将详细探讨标题为"imagenet-caffe-alex.mat"的文件及其相关知识点，...
resnet50-caffe.pth
10-22
resnet-50在ImageNet数据集上的caffe预训练模型，可以用于分类，目标检测等。
Cambricon-Caffe-User-Guide-CN-v5.3.3.pdf
09-23
Cambricon-Caffe-User-Guide-CN-v5.3.3.pdf Knowledge Points Summary 1. 概述：Cambricon-Caffe 是寒武纪基于 Caffe 框架开发的深度学习开发工具包，提供了完整的开发流程和使用指南。 2. 安装：安装 Cambricon-...
resnet-imagenet-caffe-master.zip
11-26
在本压缩包"resnet-imagenet-caffe-master.zip"中，包含的是ResNet模型在Caffe框架下的实现，主要针对ImageNet数据集进行训练和测试。 ImageNet是一个大规模的图像识别数据集，包含超过1400万张图片，分为1000个...
针对Faster RCNN具体细节以及源码的解读之SmoothL1Loss层
热门推荐
xyy19920105的博客
12-28 2万+
从今天开始，阅读faster rcnn的相关代码，并记录我对faster rcnn中特别的层的理解。本篇主要是对smooth_L1_Loss层进行解读。 RBG大神认为CPU版本的太慢了，故有些操作CPU版压根就没有实现。smooth_L1_Loss是Faster RCNN提出来的计算距离的loss，文章中提到对噪声点更加鲁棒。 输入四个bottom，分别是predict，target，insi
smooth_L1_loss_layer.cpp源码阅读
xymdsg的博客
10-31 1379
smooth_L1_loss_layer.cpp源码阅读
r-cnn学习（五）：SmoothL1LossLayer论文与代码的结合理解
weixin_30456039的博客
12-06 239
A Loss Function for Learning Region Proposals 训练RPN时，只对两种anchor给予正标签：和gt_box有着最高的IoU && IoU超过0.7。如果对于 所有的gt_box，其IoU都小于0.3，则标记为负。损失函数定义如下： 其中i为一个mini-batch中某anchor的索引，pi表示其为目标的预测概率...
smooth_L1个人理解
科技的v哦
08-01 6138
相当于是在小于1的部分使用2范数（smooth，求导方便）,在大于1的部分使用1范数(避免梯度爆炸)
caffe各层参数详解（读文档记录）
yiyisunshine的博客
03-13 3595
前言：利用caffe工具来完成自己的模型搭建与训练，层级参数还是需要好好理解的，以便进行配置文件prototxt 的编写。 数据层 数据层是每一个模型的底层，我们需要通过它完成blobs格式数据的上传。需要注意数据层的某些参数实现数据的预处理（减去均值，放大缩小，剪裁，镜像等）。 数据层的数据来源：主要是数据库（leverDB和LMDB），此时数据层的type：“Data”。 top和bottom：
Caffe学习系列(4)：激活层（Activiation Layers)及参数
weixin_34364071的博客
12-24 670
在激活层中，对输入数据进行激活操作（实际上就是一种函数变换），是逐元素进行运算的。从bottom得到一个blob数据输入，运算后，从top输入一个blob数据。在运算过程中，没有改变数据的大小，即输入和输出的数据大小是相等的。 输入：n*c*h*w 输出：n*c*h*w 常用的激活函数有sigmoid, tanh,relu等，下面分别介绍。 1、Sigmoid 对每个输入数据，利用sig...
Caffe源码：math_functions 解析
ShaowenLin
11-29 682
caffe源码中的math_functions的具体函数功能分析
caffe中对6种激活函数类的封装--Absval
u012746763的专栏
04-06 2109
absval_layer.hpp #ifndef CAFFE_ABSVAL_LAYER_HPP_ #define CAFFE_ABSVAL_LAYER_HPP_ #include #include "caffe/blob.hpp" #include "caffe/layer.hpp" #include "caffe/proto/caffe.pb.h" #include "caffe/la
Caffe代码阅读11：absval_layer层的实现
一亩半分地
08-17 5359
这一层比较简单：主要就是求绝对值，反传部分的代码也很简单 里头用到了caffe_abs这个函数以及caffe_cpu_sign这两个函数 需要注意的是caffe_cpu_sign在math_functions.hpp里头定义得比较特别 在math_functions.hpp里只有caffe_sign，通过一个宏定义生成了caffe_cpu_sign这个函数 整体来说没啥特别的内容，直接上代
Windows环境下安装Caffe-SSD与添加中心损失层Centor_Loss
"这篇教程详细介绍了如何在Windows操作系统上安装Caffe-SSD，并且添加新的中心损失层(Center Loss Layer)。作者在安装过程中遇到了问题，并根据自己的经验和其他专家的解决方案进行了总结，确保了安装过程的可行性和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

NineDays66

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值