softmax_layer的实现

Posted 2023-04-03

参考技术A Softmax是将神经网络得到的多个值，进行归一化处理，使得到的值在[0,1]之间，让结果变得可解释。Softmax可以将结果看作是概率，某个类别概率越大，将样本归为该类别的可能性也就越高，因此通常用于多分类。

下图参考李宏毅老师课件中的Softmax的计算图。图中 是神经元的输出也可以作为第 个类别预测的概率结果， 是第 个类别的真实值，只能取0或者1，且 。

在神经网络后面添加Softmax，真实的标签（或者是类别）就相当于真实的分布，经过Softmax计算出的值就是预测的结果，因此可以使用交叉熵函数来作为损失函数。Softmax的损失函数为
反向传播的过程其实就是计算 的过程，根据导数的链式法则：

根据前向计算过程得出：

当 的时候

当 的时候

根据 求导得出：

综合两项偏导数，推出：

注：因为如果给定一个样本 ，那么他对应的真实标签只有一个值为 ，其余为 ，故 。

前向计算实现
先调用softmax_cpu实现前向计算，再调用softmax_x_ent_cpu计算整个网络的损失函数值和当前层的sensitivity即l.delta的值。

这个实现很简单，就是一步步按照前面的公式，计算指数值，再求和，最后归一化。

下面的实现计算delta[i]的值的时候是真实值减去预测值，而上面推导的结果是预测值减去真实值。为什么也可以？？？

反向传播实现
softmax的敏感梯度图在softmax前向inference的时候已经计算完成，所以在反向的时候，这里只要调用axpy_cpu将对应位置的值传回去就行了。

【1】 http://freemind.pluskid.org/machine-learning/softmax-vs-softmax-loss-numerical-stability/
【2】 图示Softmax及交叉熵损失函数
【3】 Softmax函数与交叉熵

caffe源代码分析--softmax_layer.cpp

caffe源代码分析--softmax_layer.cpp

// Copyright 2013 Yangqing Jia
//
#include <algorithm>
#include <vector>

#include "caffe/layer.hpp"
#include "caffe/vision_layers.hpp"
#include "caffe/util/math_functions.hpp"

using std::max;

namespace caffe {

/**
 * 建立softmax网络层
 */
template <typename Dtype>
void SoftmaxLayer<Dtype>::SetUp(const vector<Blob<Dtype>*>& bottom,
      vector<Blob<Dtype>*>* top) {
  CHECK_EQ(bottom.size(), 1) << "Softmax Layer takes a single blob as input.";
  CHECK_EQ(top->size(), 1) << "Softmax Layer takes a single blob as output.";
  //输出分配空间
  (*top)[0]->Reshape(bottom[0]->num(), bottom[0]->channels(),
      bottom[0]->height(), bottom[0]->width());
  //sum_multiplier_这里都是1，用于辅助计算，能够看作一个行向量。或者行数为1的矩阵
  sum_multiplier_.Reshape(1, bottom[0]->channels(),
      bottom[0]->height(), bottom[0]->width());
  Dtype* multiplier_data = sum_multiplier_.mutable_cpu_data();
  for (int i = 0; i < sum_multiplier_.count(); ++i) {
    multiplier_data[i] = 1.;
  }
  //暂时变量scale_分配空间。大小为num,能够看作一个列向量
  scale_.Reshape(bottom[0]->num(), 1, 1, 1);
}

template <typename Dtype>
void SoftmaxLayer<Dtype>::Forward_cpu(const vector<Blob<Dtype>*>& bottom,
    vector<Blob<Dtype>*>* top) {
  const Dtype* bottom_data = bottom[0]->cpu_data();
  Dtype* top_data = (*top)[0]->mutable_cpu_data();
  Dtype* scale_data = scale_.mutable_cpu_data();
  //把输出看成是num层，每层dim个元素
  int num = bottom[0]->num();
  int dim = bottom[0]->count() / bottom[0]->num();
  memcpy(top_data, bottom_data, sizeof(Dtype) * bottom[0]->count());
  // we need to subtract the max to avoid numerical issues, compute the exp,
  // and then normalize.
  //找出每一层的最大值
  for (int i = 0; i < num; ++i) {
    scale_data[i] = bottom_data[i*dim];
    for (int j = 0; j < dim; ++j) {
      scale_data[i] = max(scale_data[i], bottom_data[i * dim + j]);
    }
  }
  // subtraction  通过矩阵相乘的方式来计算，有num层的top_data，每层元素减去该层的最大值。太巧妙了
  caffe_cpu_gemm<Dtype>(CblasNoTrans, CblasNoTrans, num, dim, 1, -1.,
    scale_data, sum_multiplier_.cpu_data(), 1., top_data);
  // C = alpha*op( A )*op( B ) + beta*C

  // Perform exponentiation 计算自然对数
  caffe_exp<Dtype>(num * dim, top_data, top_data);
  // sum after exp 每一层各自求和放到scale_data中
  caffe_cpu_gemv<Dtype>(CblasNoTrans, num, dim, 1., top_data,
      sum_multiplier_.cpu_data(), 0., scale_data);
  // Do division 每一层各自除以该层的和
  for (int i = 0; i < num; ++i) {
    caffe_scal<Dtype>(dim, Dtype(1.) / scale_data[i], top_data + i * dim);
  }
}

template <typename Dtype>
Dtype SoftmaxLayer<Dtype>::Backward_cpu(const vector<Blob<Dtype>*>& top,
    const bool propagate_down,
    vector<Blob<Dtype>*>* bottom) {
  const Dtype* top_diff = top[0]->cpu_diff();
  const Dtype* top_data = top[0]->cpu_data();
  Dtype* bottom_diff = (*bottom)[0]->mutable_cpu_diff();
  Dtype* scale_data = scale_.mutable_cpu_data();
  int num = top[0]->num();
  int dim = top[0]->count() / top[0]->num();
  memcpy(bottom_diff, top_diff, sizeof(Dtype) * top[0]->count());
  // Compute inner1d(top_diff, top_data) and subtract them from the bottom diff
  for (int i = 0; i < num; ++i) {
    scale_data[i] = caffe_cpu_dot<Dtype>(dim, top_diff + i * dim,
        top_data + i * dim);//每一层，top_diff和top_data计算内积
  }
  // subtraction  每一层bottom_diff的元素减去该层的相应的内积
  caffe_cpu_gemm<Dtype>(CblasNoTrans, CblasNoTrans, num, dim, 1, -1.,
      scale_data, sum_multiplier_.cpu_data(), 1., bottom_diff);
  // elementwise multiplication 元素各自相乘
  caffe_mul<Dtype>(top[0]->count(), bottom_diff, top_data, bottom_diff);
  return Dtype(0);
}


INSTANTIATE_CLASS(SoftmaxLayer);


}  // namespace caffe

本文作者：linger

本文链接：http://blog.csdn.net/lingerlanlan/article/details/32700431