修改MTCNN中caffe源码，时计算loss时以对应标签是否为“-1”判别

最新推荐文章于 2024-10-10 12:47:19 发布
最新推荐文章于 2024-10-10 12:47:19 发布
阅读量4.1k 收藏 2
点赞数 2
分类专栏： caffe源码 人脸检测 人脸关键点检测 程序代码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xzzppp/article/details/76467514
版权
MTCNN训练不收敛原因:
地址： https://github.com/dlunion/mtcnn
我们的训练数据标签格式：
wider face:
pos/001.jpg  1 x1 y1 x2 y2 (x1 y1 x2 y2) -1 -1 -1 -1 -1 -1 -1 -1 -1 -1
part/001.jpg -1 x1 y1 x2 y2 (x1 y1 x2 y2) -1 -1 -1 -1 -1 -1 -1 -1 -1 -1
neg/001.jpg  0 -1 -1 -1 -1 (x1 y1 x2 y2) -1 -1 -1 -1 -1 -1 -1 -1 -1 -1

celebA:
landmark/001.jpg -1 -1 -1 -1 -1 pst1_x pst1_y pst2_x pst2_y pst3_x pst3_y pst4_x pst4_y pst5_x pst5_y

作者要求的 训练数据标签格式：
pos/001.jpg  1 x1 y1 x2 y2 (x1 y1 x2 y2)  pst1_x pst1_y  pst2_x pst2_y   pst3_x pst3_y   pst4_x pst4_y   pst5_x pst5_y
part/001.jpg -1 x1 y1 x2 y2 (x1 y1 x2 y2)  pst1_x pst1_y  pst2_x pst2_y   pst3_x pst3_y   pst4_x pst4_y   pst5_x pst5_y
neg/001.jpg  0 -1 -1 -1 -1 (x1 y1 x2 y2)  pst1_x pst1_y  pst2_x pst2_y   pst3_x pst3_y   pst4_x pst4_y   pst5_x pst5_y

在 “ pts_loss ”层（ type: "MTCNNEuclideanLoss" ）中，以 "label"(分类的标签)来判断是否ignore。对于我们的训练数据标签格式：
class: ignore_label=-1, 可以正常分类；
bbox regression:  ignore_label=0, 有landmark中-1参加计算，导致loss无法收敛；
landmark:   ignore_label=0, 有part中-1参加计算，导致loss无法收敛；

解决思路：
在做 class， bbox regression， landmark任务时，判断便签值是否全部为—1，来作为ignore条件。

修改后"MTCNNEuclideanLoss.cpp"如下： 
#include <vector>

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

#include <iostream>
using namespace std;

namespace caffe {

template <typename Dtype>
void MTCNNEuclideanLossLayer<Dtype>::Reshape(
  const vector<Blob<Dtype>*>& bottom, const vector<Blob<Dtype>*>& top) {
  LossLayer<Dtype>::Reshape(bottom, top);
  CHECK_EQ(bottom[0]->count(1), bottom[1]->count(1))
      << "Inputs must have the same dimension.";
   
  int has_ignore_label = this->layer_param().loss_param().has_ignore_label();
  if (has_ignore_label)
	  CHECK_EQ(bottom.size(), 3) << "has_ignore_label=true but not input label";

  if (!has_ignore_label)
	  CHECK_EQ(bottom.size(), 2) << "has_ignore_label=false but input mismatch";

  diff_.ReshapeLike(*bottom[0]);
}

template <typename Dtype>
void MTCNNEuclideanLossLayer<Dtype>::Forward_cpu(const vector<Blob<Dtype>*>& bottom,
    const vector<Blob<Dtype>*>& top) {
  int count = bottom[0]->count();
  int has_ignore_label = this->layer_param().loss_param().has_ignore_label();
  int ignore_label = has_ignore_label ? this->layer_param().loss_param().ignore_label() : -1;

  if (has_ignore_label){
	  const Dtype* label = bottom[2]->cpu_data();
	  int countLabel = bottom[2]->num();

	  //label
	  Dtype* diff = diff_.mutable_cpu_data();
	  int channel = bottom[0]->channels();
	  //cout << "countLabel_forward: " << countLabel << endl;
	 //cout << "channel_forward: " << channel << endl;
	  //cout << "ignore_label_forward: " << ignore_label << endl;
	  memset(diff, 0, sizeof(Dtype)*count);

	  const Dtype* b0 = bottom[0]->cpu_data();
	  const Dtype* b1 = bottom[1]->cpu_data();
	  Dtype loss = 0;

	  // bbox regression
	  if (channel == 4)
	  {
		  for (int i = 0; i < countLabel; ++i)
		  {
			  //cout << "forware_b1_4: " << b1[i*channel + 0] << " " << b1[i*channel + 1] << " " << b1[i*channel + 2] << " " << b1[i*channel + 3] << endl;

			  int dec = (b1[i*channel + 0] != ignore_label) && (b1[i*channel + 1] != ignore_label) && (b1[i*channel + 2] != ignore_label) && (b1[i*channel + 3] != ignore_label);
			  if ( dec==1 )
			  {
				  caffe_sub(
					  channel,
					  b0 + i * channel,
					  b1 + i * channel,
					  diff + i * channel);
				  Dtype dot = caffe_cpu_dot(channel, diff + i * channel, diff + i * channel);
				  loss += dot / Dtype(2);

				  //cout << "forware_b1_4: " << b1[i*channel + 0] << " " << b1[i*channel + 1] << " " << b1[i*channel + 2] << " " << b1[i*channel + 3] << endl;
			  }
		  }
	  }

	  // landmark
	  else if (channel == 10)
	  {
		  for (int i = 0; i < countLabel; ++i)
		  {
			  //cout << "forward_b1_10: " << b1[i*channel + 0] << " " << b1[i*channel + 1] << " " << b1[i*channel + 2] << " " << b1[i*channel + 3] << " " << b1[i*channel + 4] << " ";
			  //cout << b1[i*channel + 5] << " " << b1[i*channel + 6] << " " << b1[i*channel + 7] << " " << b1[i*channel + 8] << " " << b1[i*channel + 9] << endl;

			  int dec1 = (b1[i*channel + 0] != ignore_label) && (b1[i*channel + 1] != ignore_label) && (b1[i*channel + 2] != ignore_label) && (b1[i*channel + 3] != ignore_label) && (b1[i*channel + 4] != ignore_label);
			  int dec2 = (b1[i*channel + 5] != ignore_label) && (b1[i*channel + 6] != ignore_label) && (b1[i*channel + 7] != ignore_label) && (b1[i*channel + 8] != ignore_label) && (b1[i*channel + 9] != ignore_label);
			  if (dec1==1 && dec2==1)
			  {
				  caffe_sub(
					  channel,
					  b0 + i * channel,
					  b1 + i * channel,
					  diff + i * channel);
				  Dtype dot = caffe_cpu_dot(channel, diff + i * channel, diff + i * channel);
				  loss += dot / Dtype(2);

				  //cout << "forward_b1_10: " << b1[i*channel + 0] << " " << b1[i*channel + 1] << " " << b1[i*channel + 2] << " " << b1[i*channel + 3] << " " << b1[i*channel + 4] << " ";
				  //cout << b1[i*channel + 5] << " " << b1[i*channel + 6] << " " << b1[i*channel + 7] << " " << b1[i*channel + 8] << " " << b1[i*channel + 9] << endl;
			  }
		  }
	  }

	  // ****************org data ********************
	  //for (int i = 0; i < countLabel; ++i){
		 // if (label[i] != ignore_label){
			//  caffe_sub(
			//	  channel,
			//	  b0 + i * channel,
			//	  b1 + i * channel,
			//	  diff + i * channel);
			//  Dtype dot = caffe_cpu_dot(channel, diff + i * channel, diff + i * channel);
			//  loss += dot / Dtype(2);
		 // }
	  //}
	  // ***************** ********************

	  top[0]->mutable_cpu_data()[0] = loss;
  }
  else{
	  caffe_sub(
		  count,
		  bottom[0]->cpu_data(),
		  bottom[1]->cpu_data(),
		  diff_.mutable_cpu_data());
	  Dtype dot = caffe_cpu_dot(count, diff_.cpu_data(), diff_.cpu_data());
	  Dtype loss = dot / bottom[0]->num() / Dtype(2);
	  top[0]->mutable_cpu_data()[0] = loss;
  }
}

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

	int has_ignore_label = this->layer_param().loss_param().has_ignore_label();
	int ignore_label = has_ignore_label ? this->layer_param().loss_param().ignore_label() : -1;

	if (has_ignore_label){
		const Dtype* b1 = bottom[1]->cpu_data();
		const Dtype* label = bottom[2]->cpu_data();
		int countLabel = bottom[2]->num();
		int channels = bottom[0]->channels();
		//cout << "countLabel_backword: " << countLabel << endl;
		//cout << "channels_backword: " << channels << endl;
		//cout << "ignore_label_backword: " << ignore_label << endl;
		for (int i = 0; i < 2; ++i) {
			if (propagate_down[i]) {
				memset(bottom[i]->mutable_cpu_diff(), 0, sizeof(Dtype)*bottom[i]->count());

				const Dtype sign = (i == 0) ? 1 : -1;
				const Dtype alpha = sign * top[0]->cpu_diff()[0] / bottom[i]->num();

				// bbox regression
				if (channels == 4)
				{
					for (int j = 0; j < countLabel; ++j)
					{
						int dec = (b1[j*channels + 0] != ignore_label) && (b1[j*channels + 1] != ignore_label) && (b1[j*channels + 2] != ignore_label) && (b1[j*channels + 3] != ignore_label);
						if (dec==1)
						{
							caffe_cpu_axpby(
								channels,							// count
								alpha,                              // alpha
								diff_.cpu_data() + channels * j,                   // a
								Dtype(0),                           // beta
								bottom[i]->mutable_cpu_diff() + channels * j);  // b
						}
					}
				}

				// landmark
				else if (channels == 10)
				{
					for (int j = 0; j < countLabel; ++j)
					{
						int dec1 = (b1[j*channels + 0] != ignore_label) && (b1[j*channels + 1] != ignore_label) && (b1[j*channels + 2] != ignore_label) && (b1[j*channels + 3] != ignore_label) && (b1[j*channels + 4] != ignore_label);
						int dec2 = (b1[j*channels + 5] != ignore_label) && (b1[j*channels + 6] != ignore_label) && (b1[j*channels + 7] != ignore_label) && (b1[j*channels + 8] != ignore_label) && (b1[j*channels + 9] != ignore_label);
						if (dec1 == 1 && dec2 == 1)
						{
							caffe_cpu_axpby(
								channels,							// count
								alpha,                              // alpha
								diff_.cpu_data() + channels * j,                   // a
								Dtype(0),                           // beta
								bottom[i]->mutable_cpu_diff() + channels * j);  // b
						}
					}
				}

				// ***********************org data********************
				//for (int j = 0; j < countLabel; ++j){
				//	if (label[j] != ignore_label){
				//		caffe_cpu_axpby(
				//			channels,							// count
				//			alpha,                              // alpha
				//			diff_.cpu_data() + channels * j,                   // a
				//			Dtype(0),                           // beta
				//			bottom[i]->mutable_cpu_diff() + channels * j);  // b
				//	}
				//}


			}
		}
	}
	else{
		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(
					bottom[i]->count(),              // count
					alpha,                              // alpha
					diff_.cpu_data(),                   // a
					Dtype(0),                           // beta
					bottom[i]->mutable_cpu_diff());  // b
			}
		}
	}
}

#ifdef CPU_ONLY
STUB_GPU(MTCNNEuclideanLossLayer);
#endif

INSTANTIATE_CLASS(MTCNNEuclideanLossLayer);
REGISTER_LAYER_CLASS(MTCNNEuclideanLoss);

}  // namespace caffe

相应的 "MTCNNEuclideanLoss.cu"如下： 
#include <vector>

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

#include <iostream>
using namespace std;

namespace caffe {

template <typename Dtype>
void MTCNNEuclideanLossLayer<Dtype>::Reshape(
	const vector<Blob<Dtype>*>& bottom, const vector<Blob<Dtype>*>& top) {
	LossLayer<Dtype>::Reshape(bottom, top);
	CHECK_EQ(bottom[0]->count(1), bottom[1]->count(1))
		<< "Inputs must have the same dimension.";
	 
	int has_ignore_label = this->layer_param().loss_param().has_ignore_label();
	if (has_ignore_label)
		CHECK_EQ(bottom.size(), 3) << "has_ignore_label=true but not input label";
	
	if (!has_ignore_label)
		CHECK_EQ(bottom.size(), 2) << "has_ignore_label=false but input mismatch";

	diff_.ReshapeLike(*bottom[0]);
}

template <typename Dtype>
void MTCNNEuclideanLossLayer<Dtype>::Forward_gpu(const vector<Blob<Dtype>*>& bottom,
    const vector<Blob<Dtype>*>& top) {
  int count = bottom[0]->count();
  int has_ignore_label = this->layer_param().loss_param().has_ignore_label();
  int ignore_label = has_ignore_label ? this->layer_param().loss_param().ignore_label() : -1;

  if (has_ignore_label){
	  //label
	  const Dtype* label = bottom[2]->cpu_data();
	  Dtype* diff = diff_.mutable_gpu_data();
	  int countLabel = bottom[2]->num();
	  int channel = bottom[0]->channels();
	  //cout << "ignore_label_forward: " << ignore_label << endl; //
	  caffe_gpu_memset(sizeof(Dtype)*count, 0, diff);

	  const Dtype* b0 = bottom[0]->gpu_data();
	  const Dtype* b1 = bottom[1]->gpu_data();
	  const Dtype* b1_cpu = bottom[1]->cpu_data();
	  Dtype loss = 0;

	  //cout << "channel_forward " << channel << endl;
	  // bbox regression
	  if (channel == 4)
	  {
		  for (int i = 0; i < countLabel; ++i)
		  {
			  //cout << "forware_b1_4: " << b1_cpu[i*channel + 0] << " " << b1_cpu[i*channel + 1] << " " << b1_cpu[i*channel + 2] << " " << b1_cpu[i*channel + 3] << endl;

			  int dec = (b1_cpu[i*channel + 0] != ignore_label) && (b1_cpu[i*channel + 1] != ignore_label) && (b1_cpu[i*channel + 2] != ignore_label) && (b1_cpu[i*channel + 3] != ignore_label);
			  if (dec == 1)
			  {
				  caffe_gpu_sub(
					  channel,
					  b0 + i * channel,
					  b1 + i * channel,
					  diff + i * channel);
				  Dtype dot;
				  caffe_gpu_dot(channel, diff + i * channel, diff + i * channel, &dot);
				  loss += dot / Dtype(2);
			  }
		  }
	  }

	  // landmark
	  else if (channel == 10)
	  {
		  for (int i = 0; i < countLabel; ++i)
		  {
			  int dec1 = (b1_cpu[i*channel + 0] != ignore_label) && (b1_cpu[i*channel + 1] != ignore_label) && (b1_cpu[i*channel + 2] != ignore_label) && (b1_cpu[i*channel + 3] != ignore_label) && (b1_cpu[i*channel + 4] != ignore_label);
			  int dec2 = (b1_cpu[i*channel + 5] != ignore_label) && (b1_cpu[i*channel + 6] != ignore_label) && (b1_cpu[i*channel + 7] != ignore_label) && (b1_cpu[i*channel + 8] != ignore_label) && (b1_cpu[i*channel + 9] != ignore_label);
			  if (dec1 == 1 && dec2 == 1)
			  {
				  caffe_gpu_sub(
					  channel,
					  b0 + i * channel,
					  b1 + i * channel,
					  diff + i * channel);
				  Dtype dot;
				  caffe_gpu_dot(channel, diff + i * channel, diff + i * channel, &dot);
				  loss += dot / Dtype(2);
			  }
		  }
	  }


	  // ***********************org data ********************
	  //for (int i = 0; i < countLabel; ++i){
		 // if (label[i] != ignore_label){
			//  caffe_gpu_sub(
			//	  channel,
			//	  b0 + i * channel,
			//	  b1 + i * channel,
			//	  diff + i * channel);
			//  Dtype dot;
			//  caffe_gpu_dot(channel, diff + i * channel, diff + i * channel, &dot);
			//  loss += dot / Dtype(2);
		 // }
	  //}
	  // ****************************  **********************

	  top[0]->mutable_cpu_data()[0] = loss;
  }
  else{
	  int count = bottom[0]->count();
	  caffe_gpu_sub(
		  count,
		  bottom[0]->gpu_data(),
		  bottom[1]->gpu_data(),
		  diff_.mutable_gpu_data());
	  Dtype dot;
	  caffe_gpu_dot(count, diff_.gpu_data(), diff_.gpu_data(), &dot);
	  Dtype loss = dot / bottom[0]->num() / Dtype(2);
	  top[0]->mutable_cpu_data()[0] = loss;
  }
}

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

	int has_ignore_label = this->layer_param().loss_param().has_ignore_label();
	int ignore_label = has_ignore_label ? this->layer_param().loss_param().ignore_label() : -1;

	if (has_ignore_label){
		const Dtype* b1 = bottom[1]->cpu_data();
		const Dtype* label = bottom[2]->cpu_data();
		int countLabel = bottom[2]->num();
		int channels = bottom[0]->channels();
		for (int i = 0; i < 2; ++i) {
			if (propagate_down[i]) {
				caffe_gpu_memset(sizeof(Dtype)*bottom[i]->count(), 0, bottom[i]->mutable_gpu_diff());

				const Dtype sign = (i == 0) ? 1 : -1;

				// bbox regression
				if (channels == 4)
				{
					for (int j = 0; j < countLabel; ++j)
					{
						const Dtype alpha = sign * top[0]->cpu_diff()[0];
						int dec = (b1[j*channels + 0] != ignore_label) && (b1[j*channels + 1] != ignore_label) && (b1[j*channels + 2] != ignore_label) && (b1[j*channels + 3] != ignore_label);
						if (dec == 1)
						{
							caffe_gpu_axpby(
								channels,							// count
								alpha,                              // alpha
								diff_.gpu_data() + channels * j,                   // a
								Dtype(0),                           // beta
								bottom[i]->mutable_gpu_diff() + channels * j);  // b
						}
					}
				}

				// landmark
				else if (channels == 10)
				{
					for (int j = 0; j < countLabel; ++j)
					{
						const Dtype alpha = sign * top[0]->cpu_diff()[0];
						int dec1 = (b1[j*channels + 0] != ignore_label) && (b1[j*channels + 1] != ignore_label) && (b1[j*channels + 2] != ignore_label) && (b1[j*channels + 3] != ignore_label) && (b1[j*channels + 4] != ignore_label);
						int dec2 = (b1[j*channels + 5] != ignore_label) && (b1[j*channels + 6] != ignore_label) && (b1[j*channels + 7] != ignore_label) && (b1[j*channels + 8] != ignore_label) && (b1[j*channels + 9] != ignore_label);
						if (dec1 == 1 && dec2 == 1)
						{
							caffe_gpu_axpby(
								channels,							// count
								alpha,                              // alpha
								diff_.gpu_data() + channels * j,                   // a
								Dtype(0),                           // beta
								bottom[i]->mutable_gpu_diff() + channels * j);  // b
						}
					}
				}

				// ******************* org data**********************
				//for (int j = 0; j < countLabel; ++j){
				//	const Dtype alpha = sign * top[0]->cpu_diff()[0];
				//	if (label[j] != ignore_label){
				//		caffe_gpu_axpby(
				//			channels,							// count
				//			alpha,                              // alpha
				//			diff_.gpu_data() + channels * j,                   // a
				//			Dtype(0),                           // beta
				//			bottom[i]->mutable_gpu_diff() + channels * j);  // b
				//	}
				//}



			}
		}
	}
	else{
		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
					diff_.gpu_data(),                   // a
					Dtype(0),                           // beta
					bottom[i]->mutable_gpu_diff());  // b
			}
		}
	}
}

INSTANTIATE_LAYER_GPU_FUNCS(MTCNNEuclideanLossLayer);

}  // namespace caffe

小计，完成mtcnn_educlidean_loss_layer.cu的修改，发现：const Dtype* b1 = bottom[1]->gpu_data();，gpu读取的数据是不能打印和取出来的，改成cpu模式：const Dtype* b1_cpu = bottom[1]->cpu_data()就行了；




XZZPPP
关注
专栏目录
深度学习五、MTCNN人脸检测与对齐和FaceNet人脸识别
qq_24946843的博客
03-09 7885
在说到人脸检测我们首先会想到利用Harr特征和Adaboost分类器进行人脸检测，其检测效果也是不错的，但是目前人脸检测的应用场景逐渐从室内演变到室外，从单一限定场景发展到广场、车站、地铁口等场景，人脸检测面临的要求越来越高，比如：人脸尺度多变、数量冗大、姿势多样包括俯拍人脸、戴帽子口罩等的遮挡、表情夸张、化妆伪装、光照条件恶劣、分辨率低甚至连肉眼都较难区分等。在这样复杂的环境下基于Haar特征...
tensorflow计算Loss
Deep Learning and NLP Farm
02-24 2489
def loss(self, logits, labels): #logit的shape= [batch] loss = None with tf.variable_scope('Hidden', reuse=True): W1 = tf.get_variable('W1') b1 = tf.get_variable(
深度学习——基于MTCNN算法实现人脸侦测
swpucwf的博客
09-03 2360
这里写目录标题先看效果MTCNN主体思想级联网络图像金字塔IOU算法iou 公式nms 算法数据代码训练代码侦测代码总结 先看效果 MTCNN 从2016年，MTCNN算法出来之后，属实在工业上火了一把，最近尝试着把论文代码复现了一下。 主体思想 级联网络 ** 这篇论文属于一篇多任务级联卷积神经网络，如图，利用P、R、O 三个网络来进行检测。 算法步骤： 将传入p网络中，预选一些框，生成特征图 将p网络中的预选框传入R网络中进行进一步筛选 将R网络中的预选框传入O网络中进行进一步筛选 O网络进行
修改MTCNN中caffe源码，时计算loss时以对应标签是否为“-1”判别（转）
liqiming100的专栏
09-04 314
MTCNN训练不收敛原因: 地址： https://github.com/dlunion/mtcnn 我们的训练数据标签格式： wider face: pos/001.jpg  1 x1 y1 x2 y2 (x1 y1 x2 y2) -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 part/001.jpg -1 x1 y1 x2 y2 (x1 y1 x2 y2) -1 -1 ...
loss的热图编码output与label的计算——即pytorch的nn.CrossEntropyLoss
weixin_41529093的博客
08-29 687
仅作为记录，大佬请跳过。 文章目录背景代码参考 背景 output是每一类对应一个概率值 label是其中一类 nn.CrossEntropyLoss是怎么计算 代码 import torch import torch.nn as nn import math criterion = nn.CrossEntropyLoss() output = torch.randn(1, 5, requires_grad=True) label = torch.empty(1, dtype=torch.long).
MTCNN-caffe版本训练数据
12-22
ubuntu系统16.04，基于caffe框架的MTCNN模型训练全套数据，包含已经训练好的模型，需要用的训练数据以及训练过程中间产生的数据。
Loss(四)-2017：SphereFace：在L-Softmax Loss的基础上添加了两个限制条件：||W||=1、b=0
u013250861的博客
03-04 384
如在训练时两个类别的特征输入在同一个区域时发生了区域的重叠，如图左边。二分类中，设W1、W2分别是类别1与类别2的权重，W1与W2之间的夹角是θ12，输入的特征为x，那么权重W与输入特征x之间的夹角θ就决定了输入的特征属于那个类别，因为判断概率要p1>p2，则要cos(m*θ_1)>cos(θ_2)，一般可以认为输入的特征输于类别1，则要满足m*θ1
初级入门：基于Caffe的神经网络理论与实战
u014191607的博客
05-16 761
目录： 2基于caffe的神经网络基础知识与实战 2.1 问题定义 2.2 初识神经网络 2.2.1 神经元 2.2.2 前馈过程 2.2.3 反向过程 2.3 典型CNN网络——LeNet 2.3.1 深度卷积神经网络结构 2.3.1.1 卷积层 2.3.1.2 池化层 2.3.1.3 全连接层 2.3.1.4 激活层 2.3.2 前向传播过...
人脸识别系列-Centerloss论文阅读笔记
Iriving_shu的博客
09-03 1686
好记心不如烂笔头，以此记录自己的学习历程。 这篇论文 Centerloss来自Eccv2016。本文主要讲解其核心原理以及源码和实验。 论文地址：https://ydwen.github.io/papers/WenECCV16.pdf 代码地址：https://github.com/ydwen/caffe-face简介在人脸识别中，就是要学习到一种判别性好的特征。作者通过增加centerlos
MTCNN CAFFE 版本
08-17
MTCNN CAFFE 版本可用于人脸检测 人脸对齐 训练及测试
基于caffe实现改进的mtcnn完成车牌识别.docx
05-10
博主https://blog.csdn.net/zhubenfulovepoem/article/details/81234977，文中涉及到“基于颜色定位和形态学定位改进后的mtcnn车牌定位算法”说明。
MTCNN训练
我不是萧海哇的博客
10-10 885
MTCNN是当前效果最好的开源人脸检测算法之一，作者只提供了训练好的模型以及matlab部署代码，其训练和优化在github上有很多，记录成文。 如果只是部署而没有时间训练的话，建议使用MTCNN：MTCNN部署全平台实现，包括C++、python、ncnn和tensorflow，还有加速版本和opencv直接加载版本，是所有版本中的集大成者 https://github.com/szad670401/Fast-MTCNN:快速版本实现 MTCNN优化和另类用法 训练 分为几大框架实现，依据读取数据不同，也
手把手教学训练MTCNN模型.
疯狂的鸡窝
09-14 7507
手把手教学训练MTCNN模型0 背景介绍1.关于训练集,测试集,校验集1.1 获取数据集1.2 数据集预处理mtcnn网络结构介绍预处理过程1.3 开始训练 0 背景介绍 我在学习人脸识别时,发现虽然网络上关于人脸识别理论的文章非常的多,但涉及到如何获取训练样本,如何进行预处理,以及如何去训练,并研究训练中的主要耗时情况等问题的文章非常的零散.因此在这里我结合我自己训练的步骤重头进行汇众整理并加入...
使用MXNet-MTCNN进行高效人脸检测：深度解析与应用指南
gitblog_00087的博客
04-13 344
使用MXNet-MTCNN进行高效人脸检测：深度解析与应用指南 去发现同类优质开源项目:https://gitcode.com/ 项目简介 MXNet-MTCNN是一个基于深度学习的人脸检测框架，它是由在上开源的项目。该框架是基于流行的深度学习库MXNet实现，并且结合了MTCNN（Multi-Task Convolutional Neural Networks）算法，可以实时地进行精确、高效的人...
MTCNN一些小问题讲解
qq_43703185的博客
09-06 2875
原文链接：https://zhuanlan.zhihu.com/p/92177798 原文出处：http://www.sfinst.com/?p=1683背景介绍：人脸检测，解决两个问题：1)识别图片中有没有人脸？2)如果有，人脸在哪？因此，许多人脸应用(人脸识别、面向分析)的基础是人脸检测。大多数人脸检测采用的流程为两阶段：1) 找出所有可能是人脸的候选区域2) 从候选区域中选择出最可能是人脸的区域本文的主角MTCNN，大致是这种套路，也集成了其优缺点为：准和慢。MTCNN人脸检测是2016年的论文提出来
YOLO11涨点优化：卷积魔改 | 多分支卷积模块RFB，扩大感受野提升小目标检测精度
最新发布
10-10 247
多分支卷积模块RFB，在保持参数量可扩大感受野，用来获取更高分辨率的特征，扩大感受野提升小目标检测精度。
MTCNN 测试时的一些 tips
weixin_53598445的博客
05-13 912
目录1 网络结构2 图像金字塔3 其他4 效果5 参考 1 网络结构   MTCNN 是多任务级联 CNN 的人脸检测深度学习模型，该模型不仅考虑了人脸检测概率，还综合训练了人脸边框回归和面部关键点检测，多任务同时建立 loss function 并训练，因此为 MTCNN。级联 CNN 主要由三个子网络组成：P-Net、R-Net 和 O-Net。   P-Net 的结构如下： 从网络结构上看，P-Net 接受大小为 (12，12，3) 的图片的输入，输出三种特征图，大小为 (1，1，C)，也就是说最终
MTCNN训练整理
人工智能
04-07 2万+
最新人工智能论文：http://paperreading.club MTCNN主要包括三个部分,PNet,RNet,ONet 其中PNet在训练阶段的输入尺寸为12*12,RNet的输入尺寸为24*24,ONet的输入尺寸为48*48.　PNet网络参数最小，ceffemodel仅有28.2KB,所以速度最快.RNet的网络参数次之，caffemodel大小为407.9KB,ONet的...
【Caffe实践】基于Caffe的人脸识别实现
热门推荐
1983的专栏
11-01 7万+
导言深度学习深似海、尤其是在图像人脸识别领域，最近几年的顶会和顶刊常常会出现没有太多的理论创新的文章，但是效果摆在那边。DeepID是深度学习方法进行人脸识别中的一个简单，却高效的一个网络模型，其结构的特点可以概括为两句话：1、训练一个多个人脸的分类器，当训练好之后，就可以把待测试图像放入网络中进行提取特征，2对于提取到的特征，然后就是利用其它的比较方法进行度量。具体的论文可以参照我的一篇论文笔记：
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值