深度学习笔记8：softmax层的实现

最新推荐文章于 2025-03-18 12:15:37 发布
最新推荐文章于 2025-03-18 12:15:37 发布
阅读量6.5w 收藏 124
点赞数 26
分类专栏： 深度学习 文章标签： c语言 神经网络 深度学习 cuda
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/l691899397/article/details/52291909
版权

如果有什么疑问或者发现什么错误，欢迎在评论区留言，有时间我会一一回复


softmax简介

Softmax回归模型是logistic回归模型在多分类问题上的推广，在多分类问题中，待分类的类别数量大于2，且类别之间互斥。比如我们的网络要完成的功能是识别0-9这10个手写数字，若最后一层的输出为[0,1,0, 0, 0, 0, 0, 0, 0, 0]，则表明我们网络的识别结果为数字1。

Softmax的公式为，可以直观看出如果某一个zj大过其他z,那这个映射的分量就逼近于1,其他就逼近于0，并且对所有输入数据进行归一化。


softmax层的推导

softmax层的前向计算

在我们的网络中，最后一层是softmax层。


softmax公式为，我们的softmax层有10个输入和10个输出，所以在这里n=10。前向过程只需要根据该函数进行计算即可。
Softmax还有另一种计算方法。假设zk为输入中的最大值，则softmax也可以写成这种形式，经化简2种形式是等价的。


softmax层的反向传播

设softmax的输出为a,输入为z，损失函数为loss。则 ，  。其中 在caffe中是top_diff，a为caffe中的top_data，均为已知量。需要计算的是 。

直接求导可得。
所以。


softmax层的损失函数

通常情况下softmax会被用在网络中的最后一层，用来进行最后的分类和归一化。所以其实上边softmax层的反向传播一般不会用到。

Softmax的损失函数使用的是对数损失函数 ，其中k为该样本的label（即该样本对应的正确输出，比如我们要识别的图片是数字7，则k=7，选择softmax的第7个输出值来计算loss）。一般我们进行训练时一批图片有多张，比如batch size = 16，则 。

由于我们的输入为，则。

若loss对每个输入z求导，则有。


Caffe中softmax层的实现

在caffe中，关于softmax层有2种实现，一种是SoftmaxWithLoss，可以计算出loss；另一种为softmax，只计算出每个类别的概率似然值。这样在实际使用中比较灵活。若只是想得到每个类别的概率似然值，则只需使用softmax层即可，就不需调用SoftmaxWithLoss。

SoftmaxWithLoss的配置信息如下：

layer {
  name: "loss"
  type: "SoftmaxWithLoss"
  bottom: "ip2"
  bottom: "label"
  top: "loss"
}

该层的类型为SoftmaxWithLoss，可以计算给出每个样本对应的损失函数值。他有2个输入层，分别为全连接层2和标签值label，输出为求得的多个样本的loss之和除以样本数的值。

Softmax层的配置信息如下：

layers {
  name: "prob"
  type: “Softmax"
bottom: " ip2"
  top: "prob"
}

输出为每个类别的概率值。


Caffe中softmax层相关的GPU文件为\src\caffe\layers\ softmax_layer.cu

Caffe中SoftmaxWithLoss层相关的GPU文件为\src\caffe\layers\ softmax_loss_layer.cu

下面分别介绍

前向计算

1、softmax层前向计算过程代码及注释如下

template <typename Dtype>
void SoftmaxLayer<Dtype>::Forward_gpu(const vector<Blob<Dtype>*>& bottom,
    const vector<Blob<Dtype>*>& top) {
  const Dtype* bottom_data = bottom[0]->gpu_data();
  Dtype* top_data = top[0]->mutable_gpu_data();
  Dtype* scale_data = scale_.mutable_gpu_data();
  int count = bottom[0]->count();
  int channels = top[0]->shape(softmax_axis_);
  caffe_copy(count, bottom_data, top_data);
  // compute max
  //计算最大值max，scale_data为保存最大值的变量
  kernel_channel_max<Dtype><<<CAFFE_GET_BLOCKS(outer_num_ * inner_num_),
      CAFFE_CUDA_NUM_THREADS>>>(outer_num_, channels, inner_num_, top_data,
      scale_data);
  // subtract
  //每个输入Zi均减去最大值max
  kernel_channel_subtract<Dtype><<<CAFFE_GET_BLOCKS(count),
      CAFFE_CUDA_NUM_THREADS>>>(count, outer_num_, channels, inner_num_,
      scale_data, top_data);
  // exponentiate
  //求e^(Zi-max)
  kernel_exp<Dtype><<<CAFFE_GET_BLOCKS(count), CAFFE_CUDA_NUM_THREADS>>>(
      count, top_data, top_data);
  // sum after exp
  //求和，计算e^(Zi-max),i=[0,n]之和
  kernel_channel_sum<Dtype><<<CAFFE_GET_BLOCKS(outer_num_ * inner_num_),
      CAFFE_CUDA_NUM_THREADS>>>(outer_num_, channels, inner_num_, top_data,
      scale_data);
  // divide
  //每一个指数e^(Zi-max)除以上一步求得的最大值
  kernel_channel_div<Dtype><<<CAFFE_GET_BLOCKS(count),
      CAFFE_CUDA_NUM_THREADS>>>(count, outer_num_, channels, inner_num_,
      scale_data, top_data);
}

2、SoftmaxWithLoss层前向计算过程代码及注释如下 

template <typename Dtype>
void SoftmaxWithLossLayer<Dtype>::Forward_gpu(
    const vector<Blob<Dtype>*>& bottom, const vector<Blob<Dtype>*>& top) {
  softmax_layer_->Forward(softmax_bottom_vec_, softmax_top_vec_);
  const Dtype* prob_data = prob_.gpu_data();
  const Dtype* label = bottom[1]->gpu_data();
  const int dim = prob_.count() / outer_num_;
  const int nthreads = outer_num_ * inner_num_;
  Dtype* loss_data = bottom[0]->mutable_gpu_diff();
  Dtype* counts = prob_.mutable_gpu_diff();
  //计算一个batch中每一个样本的loss
  SoftmaxLossForwardGPU<Dtype><<<CAFFE_GET_BLOCKS(nthreads),
      CAFFE_CUDA_NUM_THREADS>>>(nthreads, prob_data, label, loss_data,
      outer_num_, dim, inner_num_, has_ignore_label_, ignore_label_, counts);
  Dtype loss;
  
  //对loss求和
  caffe_gpu_asum(nthreads, loss_data, &loss);
  Dtype valid_count = -1;
  // Only launch another CUDA kernel if we actually need the count of valid
  // outputs.
  if (normalization_ == LossParameter_NormalizationMode_VALID &&
      has_ignore_label_) {
    caffe_gpu_asum(nthreads, counts, &valid_count);
  }
  
  //除以每一个batch中的样本数量
  top[0]->mutable_cpu_data()[0] = loss / get_normalizer(normalization_,
                                                        valid_count);
  if (top.size() == 2) {
    top[1]->ShareData(prob_);
  }
}

反向传播

1、softmax层反向传播过程代码及注释如下

template <typename Dtype>
void SoftmaxLayer<Dtype>::Backward_gpu(const vector<Blob<Dtype>*>& top,
    const vector<bool>& propagate_down, const vector<Blob<Dtype>*>& bottom) {
  const Dtype* top_diff = top[0]->gpu_diff();
  const Dtype* top_data = top[0]->gpu_data();
  Dtype* bottom_diff = bottom[0]->mutable_gpu_diff();
  Dtype* scale_data = scale_.mutable_gpu_data();
  int count = top[0]->count();
  int channels = top[0]->shape(softmax_axis_);
  caffe_copy(count, top_diff, bottom_diff);
  // Compute inner1d(top_diff, top_data) and subtract them from the bottom diff.
  // NOLINT_NEXT_LINE(whitespace/operators)
  kernel_channel_dot<Dtype><<<CAFFE_GET_BLOCKS(outer_num_ * inner_num_),
      CAFFE_CUDA_NUM_THREADS>>>(outer_num_, channels, inner_num_,
      top_diff, top_data, scale_data);
  // NOLINT_NEXT_LINE(whitespace/operators)
  kernel_channel_subtract<Dtype><<<CAFFE_GET_BLOCKS(count),
      CAFFE_CUDA_NUM_THREADS>>>(count, outer_num_, channels, inner_num_,
      scale_data, bottom_diff);
  // elementwise multiplication
  caffe_gpu_mul<Dtype>(top[0]->count(), bottom_diff, top_data, bottom_diff);
}

2、SoftmaxWithLoss层反向传播过程代码及注释如下

template <typename Dtype>
void SoftmaxWithLossLayer<Dtype>::Backward_gpu(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_gpu_diff();
    const Dtype* prob_data = prob_.gpu_data();
    const Dtype* top_data = top[0]->gpu_data();
	//prob_data为softmax预测结果，复制到bottom_diff
    caffe_gpu_memcpy(prob_.count() * sizeof(Dtype), prob_data, bottom_diff);
    const Dtype* label = bottom[1]->gpu_data();
    const int dim = prob_.count() / outer_num_;
    const int nthreads = outer_num_ * inner_num_;
    // Since this memory is never used for anything else,
    // we use to to avoid allocating new GPU memory.
    Dtype* counts = prob_.mutable_gpu_diff();
   	//SoftmaxLossBackwardGPU将bottom_diff中对应正确label的概率值-1，其他不变，在原内存计算
    SoftmaxLossBackwardGPU<Dtype><<<CAFFE_GET_BLOCKS(nthreads),
        CAFFE_CUDA_NUM_THREADS>>>(nthreads, top_data, label, bottom_diff,
        outer_num_, dim, inner_num_, has_ignore_label_, ignore_label_, counts);

    Dtype valid_count = -1;
    // outputs.
    if (normalization_ == LossParameter_NormalizationMode_VALID &&
        has_ignore_label_) {
      caffe_gpu_asum(nthreads, counts, &valid_count);
    }
	//除以batch size
    const Dtype loss_weight = top[0]->cpu_diff()[0] /
                              get_normalizer(normalization_, valid_count);
    caffe_gpu_scal(prob_.count(), loss_weight , bottom_diff);
  }
}





softmax层的使用
Petersburg的博客
08-31 1884
softmax是什么，怎么用
深度学习笔记5：Softmax 回归 + 损失函数 + 图片分类数据集
qq_49407329的博客
08-18 1422
学习李沐老师的深度学习（pytorch），做的笔记5（视频9）~~~
神经网络之softmax(作用，工作原理【示例说明】，损失计算)
m0_45267220的博客
03-08 1万+
神经网络之softmax,说明作用，其位于神经网络中的位置，工作原理【示例说明】，损失计算
【漫话机器学习系列】147.Softmax 归一化（Softmax Normalization）
最新发布
IT古董
03-18 1042
在机器学习和深度学习中，归一化（Normalization）是一种常见的数据预处理技术，目的是调整数据的数值范围，使其适应模型的学习需求。归一化可以提高模型的收敛速度，减少异常值（Outliers）对模型的影响，并提高模型的稳定性和泛化能力。Softmax 归一化（Softmax Normalization） 是一种特殊的归一化方法，它不仅可以将数值范围缩放到 (0,1) 之间，还能将其转换为概率分布，常用于分类任务。该方法允许在不去除异常值的情况下减少它们对数据的影响。
softmax层的实现
zhe_csdn的博客
09-22 284
https://blog.csdn.net/l691899397/article/details/52291909 Softmax回归模型是logistic回归模型在多分类问题上的推广，在多分类问题中，待分类的类别数量大于2，且类别之间互斥。比如我们的网络要完成的功能是识别0-9这10个手写数字，若最后一层的输出为[0,1,0, 0, 0, 0, 0, 0, 0, 0]，则表明我们网络的识别结果为...
Affine层/Softmax层的实现
weixin_30239339的博客
06-24 593
Affine 层 分别是形状为(2,)、(2, 3)、(3,) 的多维数组。这样一来，神经元的加权和可以用Y = np.dot(X, W) + B计算出来。 神经网络的正向传播中进行的矩阵的乘积运算在几何学领域被称为“仿射变换”。因此，这里将进行仿射变换的处理实现为“Affine层”。 Affine层的计算图（注意变量是矩阵，各个变量的上方标记了该变量的形状） ...
理解Softmax函数的原理和实现
Ven%的博客
09-05 1230
Softmax函数是机器学习和深度学习中非常基础且重要的一个概念，特别是在处理分类问题时。它的作用是将一个向量中的元素值转换成概率分布，使得每个元素的值都在0到1之间，并且所有元素值的总和为1。
caffe中的softmax layer
Buyi_Shizi的博客
05-25 1万+
在caffe中的lenet实现最后一层是softmax layer，输出分类的结果，下面就简单介绍一下softmax回归。     1，首先，在caffe中，softmax layer输出的是原始的输入在每一个分类标签上的概率，例如在lenet网络中，输出的分类共有0-9的10中分类，那么softmax layer就会输出含有10个元素的向量，每一个元素表示输入在每一个分类上的概率。
深度学习实验：Softmax实现手写数字识别_案例1 softmax实现手写数字识别(1)
2401_84182337的博客
05-08 722
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新需要这份系统化资料的朋友，可以戳这里获取from layers import FCLayerfrom dataloader import build_dataloader from network import Network from optimizer
深度学习实验：Softmax实现手写数字识别_案例1 softmax实现手写数字识别(4)
2401_84181986的博客
05-04 317
MNIST手写数字数据集是机器学习领域中广泛使用的图像分类数据集。它包含60,000个训练样本和10,000个测试样本。这些数字已进行尺寸规格化，并在固定尺寸的图像中居中。每个样本都是一个784×1的矩阵，是从原始的28×28灰度图像转换而来的。MNIST中的数字范围是0到9。下面显示了一些示例。注意：在训练期间，切勿以任何形式使用有关测试样本的信息。
深度学习实验：Softmax实现手写数字识别_案例1 softmax实现手写数字识别
2401_84181403的博客
05-16 407
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新需要这份系统化资料的朋友，可以戳这里获取 if name == ‘main’: # You can modify the hyerparameters by yourself. relu_cfg = { ‘data_root’: ‘data’, ‘max_e
深度学习笔记: 最详尽解释Softmax 回归 Softmax Regression
weixin_53765658的博客
07-21 1284
欢迎收藏Star我的Machine Learning Blog:https://github.com/purepisces/Wenqing-Machine_Learning_Blog。如果收藏star, 有问题可以随时与我交流, 谢谢大家！ Softmax 回归 Softmax 回归，也称为多项逻辑回归，是逻辑回归的广义，用于多类分类问题。虽然逻辑回归用于二分类，softmax 回归则用于类别超过两个的情况。 Softmax 回归的关键点： 多类分类：当因变量可以有两个以上的类别时，使用 softmax
caffe之SoftmaxWithLoss层 自定义实现
花泽
05-25 5962
caffe中的各层实现，因为封装了各种函数和为了扩展，在提升了效率的同时，降低了一定的代码可读性，这里，为了更好地理解softmax以及caffe中前向传播和反向传播的原理，我用通俗易懂的代码实现了SoftmaxWithLoss层（以下简称loss层），进行前向传播和反向传播，得到的训练结果和内置的代码结果是一样的。        这里定义batch_size为网络输入的批大小，label_nu
入门级都能看懂的softmax详解
热门推荐
bitcarmanlee的博客
09-02 67万+
1.softmax初探 在机器学习尤其是深度学习中，softmax是个非常常用而且比较重要的函数，尤其在多分类的场景中使用广泛。他把一些输入映射为0-1之间的实数，并且归一化保证和为1，因此多分类的概率之和也刚好为1。 首先我们简单来看看softmax是什么意思。顾名思义，softmax由两个单词组成，其中一个是max。对于max我们都很熟悉，比如有两个变量a,b。如果a&gt;b，则max为...
softmax层_AM-Softmax
weixin_39707941的博客
12-18 1017
回顾一下Angular Softmax ( A-softmax ) ，它是以乘法的方式合并angular margin(角度间隔)从上式中的 可以看出，m乘以目标角 。所以这种类型的损失函数称为：乘性Margin Softmax本文讲述的AM-Softmax提出了一种更具解释性的方法：将angular margin(角度间隔)引入到softmax loss中，提出一个新的margin。这个ma...
softmax层_Hierarchical Softmax（层次Softmax）
weixin_39600319的博客
11-26 482
在进行最优化的求解过程中：从隐藏层到输出的Softmax层的计算量很大，因为要计算所有词的Softmax概率，再去找概率最大的值。除了上篇文章讲到的负采样可以解决，Hierarchical Softmax也可以解决该问题。Huffman Tree（哈夫曼树）哈夫曼树是一种带权路径长度最短的二叉树，也称为最优二叉树。下面用一幅图来说明：图a中的数字表示权重，图a是常见的二叉树，图b就是图a转换过的最...
softmax实现
qq_43152622的博客
05-16 757
用PyTorch实现linear模型 模拟数据集 模拟数据集这块与上节课一致 num_inputs = 2 #feature number num_examples = 1000 #训练样本个数 true_w = torch.tensor([[2],[-3.4]]) #真实的权重值 true_b = torch.tensor(4.2) #真实的bias samples = torch.normal(0,1,(num_examples,num_inputs)) noise = torch.normal(0,0
softmax层_tf.nn.softmax
weixin_39822993的博客
11-24 241
tf.nn.softmax官方连接tf.nn.softmax( logits, axis=None, name=None, dim=None )作用：softmax函数的作用就是归一化。输入: 全连接层（往往是模型的最后一层）的值，一般代码中叫做logits输出: 归一化的值，含义是属于该位置的概率，一般代码叫做probs。例如输入[0.4,0.1,0.2,0....
评论 14
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值