【Caffe】softmax和softmaxwithloss层的理解

2024-08-27 19:08
文章标签 理解 caffe softmax softmaxwithloss

本文主要是介绍【Caffe】softmax和softmaxwithloss层的理解，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

softmax_axis_表示在那边切，当为1是，out_num_就表示batchsize，sum_multiplier表示通道数，scale相关的一般表示临时变量的存储，dim=C*W*H，spatial_dim=W*H，inner_num_如果fc层就为1，conv层就为H*W。

本文所举得例子是在mnist的基础上解说的，batchsize为128，类别为10。

首先看softmax求导公式：

 

 这里loss虽然由于标记形如（1,0,0,0,0,0,0,0,0,0），所以最终的loss只能由正确的那个1决定，其结果如上所示。

 虽然loss只能由正确的那个1决定，但是在分母上还是包括除了1以外的其他项，这些项对loss也是有贡献的，所以求导的时候不能忘了。

caffe中softmax的计算：

template <typename Dtype>
void SoftmaxLayer<Dtype>::Reshape(const vector<Blob<Dtype>*>& bottom,const vector<Blob<Dtype>*>& top) {softmax_axis_ =bottom[0]->CanonicalAxisIndex(this->layer_param_.softmax_param().axis());top[0]->ReshapeLike(*bottom[0]);vector<int> mult_dims(1, bottom[0]->shape(softmax_axis_));sum_multiplier_.Reshape(mult_dims);Dtype* multiplier_data = sum_multiplier_.mutable_cpu_data();caffe_set(sum_multiplier_.count(), Dtype(1), multiplier_data);outer_num_ = bottom[0]->count(0, softmax_axis_);inner_num_ = bottom[0]->count(softmax_axis_ + 1);vector<int> scale_dims = bottom[0]->shape();scale_dims[softmax_axis_] = 1;scale_.Reshape(scale_dims);
}

如上所示；在reshape阶段主要是进行相关参数维度的设定。softmax_axis主要是制定从哪个维度开始切，默认是1.后面主要是初始化了两个变量，sum_multiplier_和scale_局部变量的初始化。sum_multiplier_的形状是channel的大小，一般主要是通过矩阵乘法来实现每个feature map相对应的坐标数据进行相加或者相减或者其他的操作。scale通常情况下被用来当作临时的缓冲变量。这两个变量的使用在caffe中到处可见。接下来就是forward_cpu部分的代码。

const Dtype* bottom_data = bottom[0]->cpu_data();
Dtype* top_data = top[0]->mutable_cpu_data();
Dtype* scale_data = scale_.mutable_cpu_data();
int channels = bottom[0]->shape(softmax_axis_);
int dim = bottom[0]->count() / outer_num_;
caffe_copy(bottom[0]->count(), bottom_data, top_data);

首先还是获取top和bottom的data，把bottom的data中的数据拷贝给top，以后就直接在top中进行计算。另外在caffe中，dim变量表示的C*W*H,spatial_dim 标识的是W*H。

  for (int i = 0; i < outer_num_; ++i) {// initialize scale_data to the first planecaffe_copy(inner_num_, bottom_data + i * dim, scale_data);for (int j = 0; j < channels; j++) {for (int k = 0; k < inner_num_; k++) {scale_data[k] = std::max(scale_data[k],bottom_data[i * dim + j * inner_num_ + k]);}}// subtractioncaffe_cpu_gemm<Dtype>(CblasNoTrans, CblasNoTrans, channels, inner_num_,1, -1., sum_multiplier_.cpu_data(), scale_data, 1., top_data);// exponentiationcaffe_exp<Dtype>(dim, top_data, top_data);// sum after expcaffe_cpu_gemv<Dtype>(CblasTrans, channels, inner_num_, 1.,top_data, sum_multiplier_.cpu_data(), 0., scale_data);// divisionfor (int j = 0; j < channels; j++) {caffe_div(inner_num_, top_data, scale_data, top_data);top_data += inner_num_;}}

在上面首先是outer_num_样本数据中输入softmax的数据进行一个‘归一化’操作，大红色方框是为了找出当前instance中输入softmax的特征中的那个最大的数值，然后再减去那个最大数值防止产生数值计算方面的问题(例如在mnist数据集中，outer_num_是128代表的是batch的大小，inner_num_是1，这里的softmax前面链接的是inner product层，所以spatial_dim和inner_num的大小均为1，dim的大小是10，scale_data中其实也只有一个数，虽然caffe_copy之后有两行循环，其实由于inner_num是1，也就一行循环). 计算出最大的数值，然后把那个最大是数值乘以sum_multiplier_，就从1个数变成了C个数。继而做exp，把结果存放到topdata,然后把全部channel的数据求和(求和caffe使用矩阵和向量的乘法进行计算)存放到scale_data，形状是inner_num_,也就是W*H(其实就是1*1），最后就是除以求和结果啦。这么多的语句也就描述了表达式(1). 最主要的是考虑到了数值计算中存在的问题。

先做减法subtraction，是预防计算方面的一些问题，比如最终预测出来的结果其中一个数值为120，那么e的120次方，似乎就有点大了，如果做了相应的减法（这时，一个batch中的10个类别中最大的数值为130），那么只需要做e的（120-130）次方即可。即便其中有一个类别的数值为0，计算e的（0-130）次方，这种应该是有逼近运算，那些计算库很有可能就直接取0。

其中gemm和gemv函数请参考博客：https://blog.csdn.net/u013066730/article/details/86218269

 下面就应该是softmaxWithLoss计算损失：

先看头文件

#ifndef CAFFE_SOFTMAX_WITH_LOSS_LAYER_HPP_
#define CAFFE_SOFTMAX_WITH_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"
#include "caffe/layers/softmax_layer.hpp"namespace caffe {
template <typename Dtype>
class SoftmaxWithLossLayer : public LossLayer<Dtype> {public:
// 构造函数explicit SoftmaxWithLossLayer(const LayerParameter& param): LossLayer<Dtype>(param) {}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 "SoftmaxWithLoss"; }virtual inline int ExactNumTopBlobs() const { return -1; }virtual inline int MinTopBlobs() const { return 1; }virtual inline int MaxTopBlobs() const { return 2; }protected:
// 重载CPU和GPU正反向传导虚函数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);/// Read the normalization mode parameter and compute the normalizer based/// on the blob size.  If normalization_mode is VALID, the count of valid/// outputs will be read from valid_count, unless it is -1 in which case/// all outputs are assumed to be valid.// 返回归一化计数virtual Dtype get_normalizer(LossParameter_NormalizationMode normalization_mode, int valid_count);/// The internal SoftmaxLayer used to map predictions to a distribution./// SoftmaxLayer类实例shared_ptr<Layer<Dtype> > softmax_layer_;/// prob stores the output probability predictions from the SoftmaxLayer./// prob_作为SoftmaxLayer的输出blobBlob<Dtype> prob_;/// bottom vector holder used in call to the underlying SoftmaxLayer::Forward/// 指针指向bottom[0]，作为SoftmaxLayer的输入blobvector<Blob<Dtype>*> softmax_bottom_vec_;/// top vector holder used in call to the underlying SoftmaxLayer::Forward/// 指针指向prob_vector<Blob<Dtype>*> softmax_top_vec_;/// Whether to ignore instances with a certain label./// 标识位，是否忽略标签bool has_ignore_label_;/// The label indicating that an instance should be ignored./// 被忽略的标签值int ignore_label_;/// How to normalize the output loss./// 标识如何归一化lossLossParameter_NormalizationMode normalization_;// 维数、输出样本数，inner_nume在最开始已经介绍过了int softmax_axis_, outer_num_, inner_num_;
};}  // namespace caffe#endif  // CAFFE_SOFTMAX_WITH_LOSS_LAYER_HPP_

再看源文件

template <typename Dtype>
void SoftmaxWithLossLayer<Dtype>::LayerSetUp(const vector<Blob<Dtype>*>& bottom, const vector<Blob<Dtype>*>& top) {LossLayer<Dtype>::LayerSetUp(bottom, top);LayerParameter softmax_param(this->layer_param_);softmax_param.set_type("Softmax");softmax_layer_ = LayerRegistry<Dtype>::CreateLayer(softmax_param);softmax_bottom_vec_.clear();softmax_bottom_vec_.push_back(bottom[0]);softmax_top_vec_.clear();softmax_top_vec_.push_back(&prob_);softmax_layer_->SetUp(softmax_bottom_vec_, softmax_top_vec_);has_ignore_label_ =this->layer_param_.loss_param().has_ignore_label();if (has_ignore_label_) {ignore_label_ = this->layer_param_.loss_param().ignore_label();}if (!this->layer_param_.loss_param().has_normalization() &&this->layer_param_.loss_param().has_normalize()) {normalization_ = this->layer_param_.loss_param().normalize() ?LossParameter_NormalizationMode_VALID :LossParameter_NormalizationMode_BATCH_SIZE;} else {normalization_ = this->layer_param_.loss_param().normalization();}
}

上面是softmaxWithLoss的set函数，可以和很清楚地看到在初始化完成softmax_param这个参数之后，直接把type设置成了softmax，然后又通过工厂函数创建softmaxlayer，继而进行Set_up函数。可以看出softmaxWithLoss是内部创建了一个softmaxlayer。继续后面主要就是检查当前layer是否设定不对某个label进行计算Loss，也就是说，在mnist中有10个class，但是我只想对12345678进行分类，那就设定ignore_label为9.这个时候遇到标签是9的就不计算Loss。注意protobuf中没有设定默认的数值，has_xxx就返回false，只有设定了数值，才会true。后面的norm是为ignore服务的。

template <typename Dtype>
void SoftmaxWithLossLayer<Dtype>::Reshape(const vector<Blob<Dtype>*>& bottom, const vector<Blob<Dtype>*>& top) {LossLayer<Dtype>::Reshape(bottom, top);softmax_layer_->Reshape(softmax_bottom_vec_, softmax_top_vec_);softmax_axis_ =bottom[0]->CanonicalAxisIndex(this->layer_param_.softmax_param().axis());outer_num_ = bottom[0]->count(0, softmax_axis_);inner_num_ = bottom[0]->count(softmax_axis_ + 1);CHECK_EQ(outer_num_ * inner_num_, bottom[1]->count())<< "Number of labels must match number of predictions; "<< "e.g., if softmax axis == 1 and prediction shape is (N, C, H, W), "<< "label count (number of labels) must be N*H*W, "<< "with integer values in {0, 1, ..., C-1}.";if (top.size() >= 2) {// softmax outputtop[1]->ReshapeLike(*bottom[0]);}
}

接下来的reshape函数也没啥用处，就是设定了三个变量。softmax_axis_=1，outer_num_=128，inner_num_=1.需要注意的是outer_num_ * inner_num_必须和bottom[1]->count()给定的lable数相同。也就是说当softmax前面接inner product的时候，每个lable对应的是instance对应的类别（一个数)，但是当softmax前面是卷积层的时候，每个label就不是一个数，而是一个矩阵，对应着每个 feature map中每个像素值的分类。下面就是计算Loss：

template <typename Dtype>
void SoftmaxWithLossLayer<Dtype>::Forward_cpu(const vector<Blob<Dtype>*>& bottom, const vector<Blob<Dtype>*>& top) {// The forward pass computes the softmax prob values.softmax_layer_->Forward(softmax_bottom_vec_, softmax_top_vec_);const Dtype* prob_data = prob_.cpu_data();const Dtype* label = bottom[1]->cpu_data();int dim = prob_.count() / outer_num_;int count = 0;Dtype loss = 0;for (int i = 0; i < outer_num_; ++i) {for (int j = 0; j < inner_num_; j++) {const int label_value = static_cast<int>(label[i * inner_num_ + j]);if (has_ignore_label_ && label_value == ignore_label_) {continue;}DCHECK_GE(label_value, 0);DCHECK_LT(label_value, prob_.shape(softmax_axis_));loss -= log(std::max(prob_data[i * dim + label_value * inner_num_ + j],Dtype(FLT_MIN)));++count;}}top[0]->mutable_cpu_data()[0] = loss / get_normalizer(normalization_, count);if (top.size() == 2) {top[1]->ShareData(prob_);}
}

这里寿面是计算softmax_layer_的forward函数，softmax_top_vec_其实是prob_的一个引用。prob_data的大小是N*C*1*1.static_cast<int>(label[i * inner_num_ + j])是从对应的instance中取出相对应的标签。如果当前的label和ignore label相同，那么就不计算Loss损失，这样就存在问题，假如128个instance中有10个不计算Loss，那么最终在计算Loss的平均的时候，是除以多少呢？这就用到了norm。count在这里统计我们计算了多少个instance的Loss数值。prob_data[i * dim + label_value * inner_num_ + j] dim是10，label_value是instance的标签来当作index来从prob中取数据(该instance的分类结果),j是0，因为W=H=1。 softmax_layer_->Forward(softmax_bottom_vec_, softmax_top_vec_);这句非常关键，通过forword就会调用softmax，这样就会计算出概率值。

get_normalizer在VAILD模式下会返回我们计算了多少个Loss的个数，也就是count。这个时候当前batch的Loss就已经放回到top[0]中去了。下一步要计算的就是Loss的反向传播。其实get_normalizer就是为了防止计数为0这种情况的出现。

// CPU反向传导
template <typename Dtype>
void SoftmaxWithLossLayer<Dtype>::Backward_cpu(const vector<Blob<Dtype>*>& top,const vector<bool>& propagate_down, const vector<Blob<Dtype>*>& bottom) {if (propagate_down[1]) {LOG(FATAL) << this->type()<< " Layer cannot backpropagate to label inputs.";}if (propagate_down[0]) {Dtype* bottom_diff = bottom[0]->mutable_cpu_diff();const Dtype* prob_data = prob_.cpu_data();// 先将正向传导时计算的prob_数据(f(y_k))拷贝至偏导caffe_copy(prob_.count(), prob_data, bottom_diff);const Dtype* label = bottom[1]->cpu_data();int dim = prob_.count() / outer_num_;int count = 0;for (int i = 0; i < outer_num_; ++i) {for (int j = 0; j < inner_num_; ++j) {const int label_value = static_cast<int>(label[i * inner_num_ + j]);// 如果为忽略标签，则偏导为0if (has_ignore_label_ && label_value == ignore_label_) {for (int c = 0; c < bottom[0]->shape(softmax_axis_); ++c) {bottom_diff[i * dim + c * inner_num_ + j] = 0;}} else {// 计算偏导，预测正确的bottom_diff = f(y_k) - 1，其它不变bottom_diff[i * dim + label_value * inner_num_ + j] -= 1;++count;}}}// Scale gradient// top[0]->cpu_diff()[0] = 1.0，已在SetLossWeights()函数中初始化Dtype loss_weight = top[0]->cpu_diff()[0] /get_normalizer(normalization_, count);// 将bottom_diff归一化caffe_scal(prob_.count(), loss_weight, bottom_diff);}
}

在反向传播时，根据求导结果，可以得到求导公式：

 因此，通过caffe_copy(prob_.count(), prob_data, bottom_diff);来实现zj不等于zk的情况，通过bottom_diff[i * dim + label_value * inner_num_ + j] -= 1;来实现zj等于zk的情况。

参考 

https://blog.csdn.net/liyaohhh/article/details/52115638

https://blog.csdn.net/tianrolin/article/details/52594975

这篇关于【Caffe】softmax和softmaxwithloss层的理解的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1112526。

相关文章

深入理解Apache Airflow 调度器(最新推荐)

深入理解Apache Airflow 调度器(最新推荐)

《深入理解ApacheAirflow调度器(最新推荐)》ApacheAirflow调度器是数据管道管理系统的关键组件,负责编排dag中任务的执行,通过理解调度器的角色和工作方式,正确配置调度器,并... 目录什么是Airflow 调度器？Airflow 调度器工作机制配置Airflow调度器调优及优化建议最
阅读更多...
一文带你理解Python中import机制与importlib的妙用

一文带你理解Python中import机制与importlib的妙用

《一文带你理解Python中import机制与importlib的妙用》在Python编程的世界里,import语句是开发者最常用的工具之一,它就像一把钥匙,打开了通往各种功能和库的大门,下面就跟随小... 目录一、python import机制概述1.1 import语句的基本用法1.2 模块缓存机制1.
阅读更多...
深入理解C语言的void*

深入理解C语言的void*

《深入理解C语言的void*》本文主要介绍了C语言的void*,包括它的任意性、编译器对void*的类型检查以及需要显式类型转换的规则,具有一定的参考价值,感兴趣的可以了解一下... 目录一、void* 的类型任意性二、编译器对 void* 的类型检查三、需要显式类型转换占用的字节四、总结一、void* 的
阅读更多...
深入理解Redis大key的危害及解决方案

深入理解Redis大key的危害及解决方案

《深入理解Redis大key的危害及解决方案》本文主要介绍了深入理解Redis大key的危害及解决方案,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着... 目录一、背景二、什么是大key三、大key评价标准四、大key 产生的原因与场景五、大key影响与危
阅读更多...
深入理解C++ 空类大小

深入理解C++ 空类大小

《深入理解C++空类大小》本文主要介绍了C++空类大小,规定空类大小为1字节,主要是为了保证对象的唯一性和可区分性,满足数组元素地址连续的要求,下面就来了解一下... 目录1. 保证对象的唯一性和可区分性2. 满足数组元素地址连续的要求3. 与C++的对象模型和内存管理机制相适配查看类对象内存在C++中，规
阅读更多...
认识、理解、分类——acm之搜索

认识、理解、分类——acm之搜索

普通搜索方法有两种：1、广度优先搜索；2、深度优先搜索； 更多搜索方法： 3、双向广度优先搜索； 4、启发式搜索（包括A*算法等）； 搜索通常会用到的知识点：状态压缩（位压缩，利用hash思想压缩）。
阅读更多...
【生成模型系列（初级）】嵌入（Embedding）方程——自然语言处理的数学灵魂【通俗理解】

【生成模型系列（初级）】嵌入（Embedding）方程——自然语言处理的数学灵魂【通俗理解】

【通俗理解】嵌入（Embedding）方程——自然语言处理的数学灵魂 关键词提炼 #嵌入方程 #自然语言处理 #词向量 #机器学习 #神经网络 #向量空间模型 #Siri #Google翻译 #AlexNet 第一节：嵌入方程的类比与核心概念【尽可能通俗】 嵌入方程可以被看作是自然语言处理中的“翻译机”，它将文本中的单词或短语转换成计算机能够理解的数学形式，即向量。 正如翻译机将一种语言
阅读更多...
【C++高阶】C++类型转换全攻略：深入理解并高效应用

【C++高阶】C++类型转换全攻略：深入理解并高效应用

📝个人主页🌹：Eternity._ ⏩收录专栏⏪：C++ “ 登神长阶 ” 🤡往期回顾🤡：C++ 智能指针 🌹🌹期待您的关注 🌹🌹 ❀C++的类型转换 📒1. C语言中的类型转换📚2. C++强制类型转换⛰️static_cast🌞reinterpret_cast⭐const_cast🍁dynamic_cast 📜3. C++强制类型转换的原因📝
阅读更多...
深入理解RxJava：响应式编程的现代方式

深入理解RxJava：响应式编程的现代方式

在当今的软件开发世界中，异步编程和事件驱动的架构变得越来越重要。RxJava，作为响应式编程（Reactive Programming）的一个流行库，为Java和Android开发者提供了一种强大的方式来处理异步任务和事件流。本文将深入探讨RxJava的核心概念、优势以及如何在实际项目中应用它。 文章目录 💯 什么是RxJava？💯 响应式编程的优势💯 RxJava的核心概念
阅读更多...
如何通俗理解注意力机制？

如何通俗理解注意力机制？

1、注意力机制（Attention Mechanism）是机器学习和深度学习中一种模拟人类注意力的方法，用于提高模型在处理大量信息时的效率和效果。通俗地理解，它就像是在一堆信息中找到最重要的部分，把注意力集中在这些关键点上，从而更好地完成任务。以下是几个简单的比喻来帮助理解注意力机制： 2、寻找重点：想象一下，你在阅读一篇文章的时候，有些段落特别重要，你会特别注意这些段落，反复阅读，而对其他部分
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2