devbox
花生_TL007
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

从零开始编写深度学习库（五）PoolingLayer 网络层CPU编写_pooling 操作 库

作者：花生_TL007 | 2024-02-13 01:04:52

赞

踩

pooling 操作 库

记录：编写卷积层和池化层，比较需要注意的细节就是边界问题，还有另外一个就是重叠池化的情况，这两个小细节比较重要，边界问题pad在反向求导的时候，由于tensorflow是没有计算的，另外一个比较烦人的是Eigen::Tensor的rowmajor、和colmajor问题，也很烦人。为了跟tensorflow做比较，一些边界处理上的细节，需要特别注意。

一、c++、maxpooling、avgpooling

  1. #pragma once
  2. #include "config.h"
  3. #include <vector>
  4. enum PoolingMethod
  5. {
  6. 	max,
  7. 	avg
  8.  
  9. };
  10.  
  11.  
  12.  
  13. class CPoolingLayer
  14. {
  15. public:
  16.  
  17. 	CPoolingLayer(std::vector<int>pooling_shape,PoolingMethod pooling_method, int padding = 0) {
  18. 		m_hksize = pooling_shape[0];
  19. 		m_wksize = pooling_shape[1];
  20. 		m_hstride = pooling_shape[2];
  21. 		m_wstride = pooling_shape[3];
  22.  
  23. 		m_padding = padding;
  24. 		m_pooling_method = pooling_method;
  25.  
  26.  
  27.  
  28. 		
  29. 	};
  30. 	~CPoolingLayer() {
  31. 	};
  32. 	//返回(bottom[0],bottom[1]/hstride*bottom[2]/wstride,hsize,wsize,bottom[3])
  33. 	void CPoolingLayer::extract_image_patches(const Tensor4xf &bottom, Tensor5xf &patches) {
  34. 		//这个Eigen tensor类的extract_image_patches函数，由于有数据存储列排列、行排列两种不同的模式。
  35. 		//在下面函数中，如果是采用rowmajor，下面的调用方式才是正确的
  36. 		//不能采用bottom.extract_image_patches(  m_hksize,m_wksize, m_hstride,m_wstride, 1, 1);
  37. 		//switch (m_padding_method)
  38. 		//{
  39. 		//case valid:
  40. 			patches = bottom.extract_image_patches(m_hksize, m_wksize, m_hstride, m_wstride, 1, 1,
  41. 				Eigen::PADDING_VALID);
  42. 			//break;
  43. 		//case same:
  44. 			//patches = bottom.extract_image_patches(m_hksize, m_wksize, m_hstride, m_wstride, 1, 1,
  45. 				//Eigen::PADDING_SAME );
  46. 			//break;
  47. 		//default:
  48. 			//break;
  49. 		//}
  50. 			
  51. 	}
  52. 	//根据stride、size等计算输出数据的维度形状
  53. 	Eigen::DSizes<int, 4> CPoolingLayer::get_top_shape(const Tensor4xf&bottom) {
  54. 		Eigen::DSizes<int, 4>top_shape;
  55. 		top_shape[0] = bottom.dimension(0);
  56. 		//switch (m_padding_method)
  57. 		//{
  58. 		//case valid:
  59. 			top_shape[1] = Eigen::divup(float(bottom.dimension(1) - m_hksize + 1), float(m_hstride));
  60. 			top_shape[2] = Eigen::divup(float(bottom.dimension(2) - m_wksize + 1), float(m_wstride));
  61. 			//break;
  62. 		//case same:
  63. 			//top_shape[1] = Eigen::divup(float(bottom.dimension(1)), float(m_hstride));
  64. 			//top_shape[2] = Eigen::divup(float(bottom.dimension(2)), float(m_wstride));
  65.  
  66. 			//break;
  67. 		//default:
  68. 			//break;
  69. 		//}
  70. 		top_shape[3] = bottom.dimension(3);
  71. 		return top_shape;
  72. 	}
  73.  
  74. 	//需要特别注意这边的均值池化，与tesorflow，在same模式下处理方式不同，tensorflow的在计算池化的时候，
  75. 	//不管有没有padding，padding值在计算池化操作都被忽略
  76. 	// bottom(batch_size, input_height, input_width, input_channel);
  77. 	void CPoolingLayer::forward(const Tensor4xf&bottom,Tensor4xf&top, const Eigen::ThreadPoolDevice &device) {
  78. 		Tensor4xf pad_bottom;
  79. 		CBaseFunction::padding_forward(bottom, m_padding, m_padding, pad_bottom);
  80. 		
  81.  
  82. 		Eigen::array<int, 2> reduction_dims{1,2};//第二维、第三维的大小等于（hksize、wksize）
  83. 		Eigen::DSizes<int, 4>post_reduce_dims=get_top_shape(pad_bottom);
  84.  
  85. 		Tensor5xf patches; //(bottom[0],  hsize, wsize,bottom[1] / hstride*bottom[2] / wstride, bottom[3])
  86. 		extract_image_patches(pad_bottom, patches);
  87.  
  88.  
  89. 		Tensor3xf pooling(post_reduce_dims[0],post_reduce_dims[1]*post_reduce_dims[2],post_reduce_dims[3]);
  90. 		switch (m_pooling_method)
  91. 		{
  92. 		case avg:
  93. 			pooling.device(device) = patches.mean(reduction_dims);//对reduction_dims内对应的维度索引进行统计，比如统计第3、2
  94. 			break;
  95. 		case max:
  96. 			pooling.device(device) = patches.maximum(reduction_dims);//最大池化
  97. 			break;
  98. 		default:
  99. 			break;
  100. 		}		
  101. 		top=pooling.reshape(post_reduce_dims);
  102.  
  103. 	}
  104. 	//本函数主要用于索引解码，从一维索引到获取多维下标值。主要原因在于：max
  105. 	std::vector<int> CPoolingLayer::decode_index(std::vector<int>dim,int index) {
  106. 		std::vector<int>result;
  107. 		for (int i=0;i<5;i++)
  108. 		{
  109. 			int accu = 1;
  110. 			for (int j=5-1;j>i;j--)
  111. 			{
  112. 				accu *= dim[j];
  113.  
  114. 			}
  115. 			result.push_back(std::floor(index / accu));
  116. 			index = index%accu;
  117. 		}
  118.  
  119. 		return result;
  120.  
  121. 	}
  122. 	//主要是重叠池化的时候，反向求导的时候是微分值累加。
  123. 	void CPoolingLayer::maxpooling_backward(const Tensor4xf&bottom,const Tensor4xf&dtop,Tensor4xf&dbottom) {
  124. 		Tensor4xf pad_bottom;
  125. 		CBaseFunction::padding_forward(bottom, m_padding, m_padding, pad_bottom);
  126. 		Tensor5xf patches; 
  127. 		extract_image_patches(pad_bottom, patches);
  128. 		Tensor4xf dpad_bottom(pad_bottom.dimension(0), pad_bottom.dimension(1), pad_bottom.dimension(2), pad_bottom.dimension(3));
  129. 		dpad_bottom.setZero();
  130.  
  131.  
  132.  
  133. 		Eigen::DSizes<int, 4>post_reduce_dims = get_top_shape(pad_bottom);
  134. 		Eigen::array<Eigen::DenseIndex, 2> reduce_dims{ 1,2 };
  135. 		auto index_tuples = patches.index_tuples();
  136. 		Eigen::Tensor<Eigen::Tuple<Eigen::DenseIndex, float>, 3, Eigen::internal::traits<Tensor5xf>::Layout> reduced_by_dims;
  137. 		reduced_by_dims = index_tuples.reduce(reduce_dims, Eigen::internal::ArgMaxTupleReducer<Eigen::Tuple<Eigen::DenseIndex, float> >());
  138.  
  139.  
  140. 		int batch = dtop.dimension(0);
  141. 		int height = dtop.dimension(1);
  142. 		int widht = dtop.dimension(2);
  143. 		int channel = dtop.dimension(3);
  144. 		bool isColMajor = (Eigen::internal::traits<Tensor4xf>::Layout ==Eigen::ColMajor);
  145.  
  146. 		for (int b= 0; b < batch; b++)
  147. 		{
  148. 			for (int h = 0; h< height; h++)
  149. 			{
  150. 				for (int w = 0; w < widht; w++)
  151. 				{
  152. 					for (int c = 0; c <channel ; c++)
  153. 					{
  154. 						const auto &dmax_element = dtop(b, h, w, c);
  155. 						
  156. 						int max_inpatch_height;
  157. 						int max_inpatch_width;
  158. 						if (isColMajor) {//如果是列主元存储，那么维度的序号刚好相反，由(b,h,w,c)变成(c,w,h,b)
  159. 							const Eigen::Tuple<Eigen::DenseIndex, float>&v = reduced_by_dims(c*widht*height*batch + w*height*batch + h*batch + b);
  160. 							int index_in_patch = v.first % (m_wksize*m_hksize);//最大值在每个块中的索引
  161. 							max_inpatch_height = index_in_patch%m_hksize;
  162. 							max_inpatch_width = index_in_patch / m_hksize;
  163.  
  164. 							
  165. 						}
  166. 						else{						
  167. 							const Eigen::Tuple<Eigen::DenseIndex, float>&v = reduced_by_dims(b*height*widht*channel + h*widht*channel + w*channel + c);
  168. 							int index_in_patch = v.first % (m_wksize*m_hksize);//最大值在每个块中的索引
  169. 							max_inpatch_height = index_in_patch/m_wksize;
  170. 							max_inpatch_width = index_in_patch % m_wksize;
  171. 						}
  172. 						
  173. 						
  174. 						int patch_height = h*m_hstride + max_inpatch_height;
  175. 						int patch_width = w*m_wstride + max_inpatch_width;
  176. 						dpad_bottom(b, patch_height, patch_width, c) += dmax_element;
  177. 						/*if (patch_height < dbottom.dimension(1) && patch_width < dbottom.dimension(2))
  178. 						{
  179. 							
  180. 							dbottom(b, patch_height, patch_width, c) += dmax_element;
  181. 						}
  182. 						else
  183. 						{
  184. 							std::cout << "out of range" << std::endl;
  185. 						}*/			
  186. 					}
  187. 				}
  188. 			}
  189. 		}
  190. 		CBaseFunction::padding_backward(dpad_bottom, m_padding, m_padding, dbottom);
  191.  
  192.  
  193. 	}
  194. 	//均值池化，也可以看成是卷积
  195. 	void CPoolingLayer::avgpooling_backward(const Tensor4xf&dtop, Tensor4xf&dbottom) {
  196.  
  197.  
  198. 		Tensor4xf mean_coffe = dtop*(1.f / (m_wksize*m_hksize));//均值池化反向求导要除以均值系数
  199.  
  200. 		for (int b=0;b<mean_coffe.dimension(0);b++)
  201. 		{
  202. 			for (int h=0;h<mean_coffe.dimension(1);h++)
  203. 			{
  204. 				for (int w=0;w<mean_coffe.dimension(2);w++)
  205. 				{
  206. 					for (int c=0;c<mean_coffe.dimension(3);c++)
  207. 					{
  208. 						const auto &mean_element= mean_coffe(b, h, w, c);
  209. 						for (int kh=0;kh<m_hksize;kh++)
  210. 						{
  211. 							for (int kw=0;kw<m_wksize;kw++)
  212. 							{
  213. 								int patch_height = h*m_hstride + kh - m_padding;
  214. 								int patch_width = w*m_wstride + kw - m_padding;
  215. 								if (patch_height>=0 &&patch_width>=0&&patch_width<dbottom.dimension(2)&&patch_height<dbottom.dimension(1))
  216. 								{
  217. 									dbottom(b, patch_height, patch_width,c) += mean_element;
  218. 								}						
  219. 							}
  220. 						}
  221. 					}
  222. 				}
  223. 			}
  224. 		}
  225.  
  226. 		//CBaseFunction::padding_backward(dpad_bottom, m_padding_method, m_padding_method, dbottom);
  227.  
  228. 	}
  229. 	void CPoolingLayer::backward(const Tensor4xf&bottom,const Tensor4xf&dtop, Tensor4xf&dbottom, const Eigen::ThreadPoolDevice &device) {
  230. 		dbottom.setZero();
  231. 		//计算第2、3维的降维
  232. 		switch (m_pooling_method)
  233. 		{
  234. 		case max:
  235. 			maxpooling_backward(bottom, dtop, dbottom);
  236. 			break;
  237. 		case avg:
  238. 			avgpooling_backward(dtop, dbottom);
  239. 			break;
  240. 		default:
  241. 			break;
  242. 		}
  243.  
  244.  
  245.  
  246.  
  247. 	}
  248. private:
  249. 	int m_hksize;//池化块的长宽
  250. 	int m_wksize;
  251. 	int m_hstride;//池化步长
  252. 	int m_wstride;
  253. 	
  254. 	int m_padding;//边界处理方法
  255. 	PoolingMethod m_pooling_method;//池化方法：均值池化、最大池化等
  256.  
  257. };
  258.  
  259.  
  260. class CPoolingLayer_test
  261. {
  262. public:
  263. 	static void CPoolingLayer_test::test() {
  264.  
  265.  
  266. 		Eigen::ThreadPool *tp = new Eigen::ThreadPool(8);
  267. 		Eigen::ThreadPoolDevice device(tp, 8);
  268.  
  269. 		int batch_size = 1;
  270. 		int input_channel =1;
  271. 		int input_height =5;
  272. 		int input_width =5;
  273. 		int kenel_height = 3;
  274. 		int kenel_widht = 2;
  275. 		int khstride =2;
  276. 		int kwstride = 3;
  277. 		int pad = 0;
  278.  
  279.  
  280. 		Tensor4xf bottom(batch_size, input_height, input_width, input_channel);
  281. 		int count = 0;
  282. 		for (int i=0;i<batch_size;i++)
  283. 		{
  284. 			for (int j=0;j<input_height;j++)
  285. 			{
  286. 				for (int k=0;k<input_width;k++)
  287. 				{
  288. 					for (int h=0;h<input_channel;h++)
  289. 					{
  290. 						bottom(i, j, k, h) = 0.1f*count;
  291. 						count++;
  292. 					}
  293. 				}
  294. 			}
  295. 		}
  296.  
  297.  
  298. 		Tensor1xf label_1d(batch_size);
  299. 		for (int i = 0; i < batch_size; i++)
  300. 		{
  301. 			label_1d(i) = i;
  302. 		}
  303.  
  304.  
  305.  
  306.  
  307. 		
  308. 		
  309.  
  310.  
  311. 		//第一层：pooling层
  312. 		CPoolingLayer layer({kenel_height,kenel_widht,khstride,kwstride },PoolingMethod::max,pad);
  313.  
  314.  
  315. 		Tensor4xf top;
  316. 		layer.forward(bottom, top,device);
  317.  
  318. 		Tensor2xf top_flatten;
  319. 		CBaseFunction::flatten(top, top_flatten);
  320.  
  321.  
  322. 		//第二层：sotfmax网络层
  323. 		Tensor2xf one_hot;
  324. 		CBaseFunction::onehot(label_1d, top_flatten.dimension(1), one_hot);
  325. 		Tensor2xf dtop_flatten(top_flatten);
  326. 		float loss = CBaseFunction::softmax_with_loss(top_flatten, one_hot, dtop_flatten, device);
  327.  
  328. 		Tensor4xf dtop;
  329. 		CBaseFunction::reshape_like(dtop_flatten, top, dtop);
  330.  
  331.  
  332.  
  333. 		Tensor4xf dbottom(bottom);
  334.  
  335. 		layer.backward(bottom, dtop,dbottom,device);
  336.  
  337.  
  338. 		//Tensor4rf dbottom_swap = dbottom.swap_layout();
  339. 		std::cout << "***************forward************" << std::endl;
  340. 		//CBaseFunction::print_shape(one_hot);
  341. 		CBaseFunction::print_shape(dbottom);
  342. 		CBaseFunction::print_element(dbottom);
  343. 		//std::cout << "bottom" << bottom<< std::endl;
  344. 		//std::cout << "top" << top << std::endl;
  345. 		//std::cout << "dbottom" << dbottom << std::endl;
  346. 		std::cout << "loss" << loss << std::endl;
  347. 		
  348. 		//std::cout << "dbottom" << dbottom << std::endl;
  349. 		//std::cout << "dtop" << top << std::endl;
  350.  
  351.  
  352.  
  353.  
  354.  
  355. 	}
  356.  
  357. };
二、tensorflow 验证结果： 

  1. import  tensorflow as tf
  2.  
  3. batch_size = 1
  4. input_channel = 1
  5. input_height =5
  6. input_width = 5
  7.  
  8. kenel_height =3
  9. kenel_widht =2
  10. khstride =2
  11. kwstride=3
  12. pad=0
  13. bottom=tf.constant([i*0.1 for i in range(batch_size*input_channel*input_height*input_width)],shape=(batch_size,input_height,input_width,input_channel),dtype=tf.float32)
  14.  
  15.  
  16.  
  17. pool1=tf.nn.max_pool(tf.pad(bottom,[[0,0],[pad,pad],[pad,pad],[0,0]]),[1,kenel_height,kenel_widht,1],strides=[1,khstride,kwstride,1],padding='VALID')
  18. pool_flatten=tf.reshape(pool1,[batch_size,-1])
  19.  
  20. label=tf.constant([i for i in range(batch_size)])
  21. one_hot=tf.one_hot(label,pool_flatten.get_shape().as_list()[1])
  22.  
  23.  
  24. predicts=tf.nn.softmax(pool_flatten)
  25. loss =-tf.reduce_mean(one_hot * tf.log(predicts))
  26.  
  27. #打印相关变量，梯度等，验证是否与c++结果相同
  28. dbottom,dpool1=tf.gradients(loss,[bottom,pool1])
  29.  
  30. with tf.Session() as sess:
  31. 	sess.run(tf.global_variables_initializer())
  32.  
  33. 	print (sess.run([dbottom]))
  34.  
  35. 	print (sess.run(loss))
  36.  
  37. 	#print ('dbottom_data',dbottom_data)



声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/花生_TL007/article/detail/79213
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号