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

最新推荐文章于 2024-03-04 01:16:20 发布
最新推荐文章于 2024-03-04 01:16:20 发布
阅读量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 7849
在说到人脸检测我们首先会想到利用Harr特征和Adaboost分类器进行人脸检测，其检测效果也是不错的，但是目前人脸检测的应用场景逐渐从室内演变到室外，从单一限定场景发展到广场、车站、地铁口等场景，人脸检测面临的要求越来越高，比如：人脸尺度多变、数量冗大、姿势多样包括俯拍人脸、戴帽子口罩等的遮挡、表情夸张、化妆伪装、光照条件恶劣、分辨率低甚至连肉眼都较难区分等。在这样复杂的环境下基于Haar特征...
初级入门：基于Caffe的神经网络理论与实战
u014191607的博客
05-16 737
目录： 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 前向传播过...
tensorflow计算Loss
Deep Learning and NLP Farm
02-24 2475
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中caffe源码，时计算loss时以对应标签是否为“-1”判别（转）
liqiming100的专栏
09-04 308
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 659
仅作为记录，大佬请跳过。 文章目录背景代码参考 背景 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 363
如在训练时两个类别的特征输入在同一个区域时发生了区域的重叠，如图左边。二分类中，设W1、W2分别是类别1与类别2的权重，W1与W2之间的夹角是θ12，输入的特征为x，那么权重W与输入特征x之间的夹角θ就决定了输入的特征属于那个类别，因为判断概率要p1>p2，则要cos(m*θ_1)>cos(θ_2)，一般可以认为输入的特征输于类别1，则要满足m*θ1
人脸识别系列-Centerloss论文阅读笔记
Iriving_shu的博客
09-03 1672
好记心不如烂笔头，以此记录自己的学习历程。 这篇论文 Centerloss来自Eccv2016。本文主要讲解其核心原理以及源码和实验。 论文地址：https://ydwen.github.io/papers/WenECCV16.pdf 代码地址：https://github.com/ydwen/caffe-face简介在人脸识别中，就是要学习到一种判别性好的特征。作者通过增加centerlos
论文阅读瞎记(四) Cascade R-CNN: Delving into High Quality Object Detection 2017
Pleadge的博客
03-22 3241
概述 在物体检测中1，IOU阈值被用于判定正负样本。在低IOU阈值比如0.5的状态下训练模型经常产生噪音预测，然而检测效果会随着IOU增加而降低。两个主要因素：1.训练时的过拟合，正样本指数消失 2.inference-time mismatch between the IoUs for which the detector is optimal and those of the input hypotheses.（后处理的问题？）一个单阶段的物体检测器CascadeR-CNN被提出用于解决这些问题。网络
基于caffe实现改进的mtcnn完成车牌识别.docx
05-10
博主https://blog.csdn.net/zhubenfulovepoem/article/details/81234977，文中涉及到“基于颜色定位和形态学定位改进后的mtcnn车牌定位算法”说明。
MTCNN CAFFE 版本
08-17
MTCNN CAFFE 版本可用于人脸检测 人脸对齐 训练及测试
MTCNN人脸检测数据集（经处理优化 可直接训练）
08-03
图像尺寸为12,24,48的三个文件夹，分别包含正、负、部分样本20万张，共60万。 包含置信度、回归框、5个人脸特征点偏移量的txt文件，可直接提取为训练标签。 图像经过优化处理，建议框比CelebA数据集更加准确。可用MTCNN直接训练。 https://blog.csdn.net/weixin_43565802/article/details/107535599
MTCNN训练
萧海的博客
10-10 874
MTCNN是当前效果最好的开源人脸检测算法之一，作者只提供了训练好的模型以及matlab部署代码，其训练和优化在github上有很多，记录成文。 如果只是部署而没有时间训练的话，建议使用MTCNN：MTCNN部署全平台实现，包括C++、python、ncnn和tensorflow，还有加速版本和opencv直接加载版本，是所有版本中的集大成者 https://github.com/szad670401/Fast-MTCNN:快速版本实现 MTCNN优化和另类用法 训练 分为几大框架实现，依据读取数据不同，也
mtcnn训练
edmond999的专栏
11-15 8500
最近在搞人脸检测，准备学习一下如何训练，先参考一下试试，后续更新内容 https://github.com/dlunion/mtcnn
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的...
人脸检测——MTCNN
wzy的博客
03-23 1万+
本次介绍一篇速度还不错的人脸检测文章： 《2016 Joint Face Detection and Alignment using Multi-task Cascaded Convolutional Networks》. 源代码作者刚刚公布，效果相当不错（只有测试代码）：  https://kpzhang93.github.io/MTCNN_face_detection_align
人脸检测和对齐--MTCNN训练1--P-net
VivienFu的专栏
06-23 9860
采用数据集： 人脸检测和人脸框回归：WIDER_FACE 特征点标定：Celeba（P-net未使用） P-net: P-net的任务是人脸检测和人脸框回归，所以该阶段仅需要使用WIDER FACE数据集。 （1）取候选窗，生成训练图片 下载的原始数据集并不能直接用于训练，而是在原始图像上截取候选框图像。随机截取候选框，根据IoU计算候选框所属类别，并将其resize到12*1
MTCNN 训练记录（待续）
pingfan2014的博客
01-24 1356
训练 1.基础问题 a.样本问题，mtcnn训练时，会把训练的原图样本，通过目标所在区域进行裁剪，得到三类训练样本，即：正样本、负样本、部分(part)样本 其中： 裁剪方式：对目标区域，做平移、缩放等变换得到裁剪区域 IoU：目标区域和裁剪区域的重合度 此时三类样本如下定义： 正样本：IoU &gt;= 0.65，标签为1 负样本：IoU &lt; 0.3，标签为0 部分(part)样本：0....
"深入解析caffe源码中的CUDA_KERNEL_LOOP宏定义
在对Caffe源码进行分析过程中，我们首先研究了math_functions.cu中的代码。在该代码中，我们发现了一个非常重要的宏定义，即CUDA_KERNEL_LOOP。这个宏定义实际上是在common.hpp文件中进行了定义和实现的。 在深入...
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值