caffe中带权重的softmaxloss实现（一）

最新推荐文章于 2024-08-06 21:06:26 发布
最新推荐文章于 2024-08-06 21:06:26 发布
阅读量1.1w 收藏 9
点赞数 2
分类专栏： caffe
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/langb2014/article/details/53005482
版权

长话短说，先看一个简单的shicai （做个申明代码归作者所有，我先从简单讲起，最近比较忙后面内容还在更新）

Weighted Softmax Loss Layer for Caffe

Usage:

（1）caffe.proto文件修改以下部分，增加pos_mult（指定某类的权重乘子）和pos_cid（指定的某类的类别编号）两个参数：

// Message that stores parameters used by SoftmaxLayer, SoftmaxWithLossLayer
message SoftmaxParameter {
  enum Engine {
    DEFAULT = 0;
    CAFFE = 1;
    CUDNN = 2;
  }
  optional Engine engine = 1 [default = DEFAULT];

  // The axis along which to perform the softmax -- may be negative to index
  // from the end (e.g., -1 for the last axis).
  // Any other axes will be evaluated as independent softmaxes.
  optional int32 axis = 2 [default = 1];
  optional float pos_mult = 3 [default = 1];
  optional int32 pos_cid = 4 [default = 1];
}

 

（2）include\caffe\loss_layers.hpp，增加以下部分：

/**
 * @brief A weighted version of SoftmaxWithLossLayer.
 *
 * TODO: Add description. Add the formulation in math.
 */
template <typename Dtype>
class WeightedSoftmaxWithLossLayer : public LossLayer<Dtype> {
 public:
   /**
    * @param param provides LossParameter loss_param, with options:
    *  - ignore_label (optional)
    *    Specify a label value that should be ignored when computing the loss.
    *  - normalize (optional, default true)
    *    If true, the loss is normalized by the number of (nonignored) labels
    *    present; otherwise the loss is simply summed over spatial locations.
    */
  explicit WeightedSoftmaxWithLossLayer(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 "WeightedSoftmaxWithLoss"; }
  virtual inline int ExactNumBottomBlobs() const { return -1; }
  virtual inline int MinBottomBlobs() const { return 1; }
  virtual inline int MaxBottomBlobs() const { return 2; }
  virtual inline int ExactNumTopBlobs() const { return -1; }
  virtual inline int MinTopBlobs() const { return 1; }
  virtual inline int MaxTopBlobs() const { return 2; }

 protected:
  /// @copydoc WeightedSoftmaxWithLossLayer
  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);
  /**
   * @brief Computes the softmax loss error gradient w.r.t. the predictions.
   *
   * Gradients cannot be computed with respect to the label inputs (bottom[1]),
   * so this method ignores bottom[1] and requires !propagate_down[1], crashing
   * if propagate_down[1] is set.
   *
   * @param top output Blob vector (length 1), providing the error gradient with
   *      respect to the outputs
   *   -# @f$ (1 \times 1 \times 1 \times 1) @f$
   *      This Blob's diff will simply contain the loss_weight* @f$ \lambda @f$,
   *      as @f$ \lambda @f$ is the coefficient of this layer's output
   *      @f$\ell_i@f$ in the overall Net loss
   *      @f$ E = \lambda_i \ell_i + \mbox{other loss terms}@f$; hence
   *      @f$ \frac{\partial E}{\partial \ell_i} = \lambda_i @f$.
   *      (*Assuming that this top Blob is not used as a bottom (input) by any
   *      other layer of the Net.)
   * @param propagate_down see Layer::Backward.
   *      propagate_down[1] must be false as we can't compute gradients with
   *      respect to the labels.
   * @param bottom input Blob vector (length 2)
   *   -# @f$ (N \times C \times H \times W) @f$
   *      the predictions @f$ x @f$; Backward computes diff
   *      @f$ \frac{\partial E}{\partial x} @f$
   *   -# @f$ (N \times 1 \times 1 \times 1) @f$
   *      the labels -- ignored as we can't compute their error gradients
   */
  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);


  /// The internal SoftmaxLayer used to map predictions to a distribution.
  shared_ptr<Layer<Dtype> > softmax_layer_;
  /// prob stores the output probability predictions from the SoftmaxLayer.
  Blob<Dtype> prob_;
  /// bottom vector holder used in call to the underlying SoftmaxLayer::Forward
  vector<Blob<Dtype>*> softmax_bottom_vec_;
  /// top vector holder used in call to the underlying SoftmaxLayer::Forward
  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_;
  /// Whether to normalize the loss by the total number of values present
  /// (otherwise just by the batch size).
  bool normalize_;
  int softmax_axis_, outer_num_, inner_num_;

  float pos_mult_;
  int pos_cid_;
};

 

（3）在src\caffe\layers文件夹中增加weighted_softmax_loss_layer.cpp和weighted_softmax_loss_layer.cu两个文件

cpp:

#include <algorithm>
#include <cfloat>
#include <vector>

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

namespace caffe {

template <typename Dtype>
void WeightedSoftmaxWithLossLayer<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_);
  pos_mult_ = this->layer_param_.softmax_param().pos_mult();
  pos_cid_ = this->layer_param_.softmax_param().pos_cid();

  LOG(INFO) << "mult: " << pos_mult_ << ", id: " << pos_cid_;

  has_ignore_label_ =
    this->layer_param_.loss_param().has_ignore_label();
  if (has_ignore_label_) {
    ignore_label_ = this->layer_param_.loss_param().ignore_label();
  }
  normalize_ = this->layer_param_.loss_param().normalize();
}

template <typename Dtype>
void WeightedSoftmaxWithLossLayer<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);
  LOG(INFO) << "outer_num_: " << outer_num_ << ", inner_num_: " << inner_num_;

  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 output
    top[1]->ReshapeLike(*bottom[0]);
  }
}

template <typename Dtype>
void WeightedSoftmaxWithLossLayer<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;
   LOG(INFO) << "dim:" << dim;

   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_));
      Dtype w = (label_value == pos_cid_) ? pos_mult_ : 1;
      loss -= w * log(std::max(prob_data[i * dim + label_value * inner_num_ + j],
                               Dtype(FLT_MIN)));
      ++count;
    }
  }
  if (normalize_) {
    top[0]->mutable_cpu_data()[0] = loss / count;
  } else {
    top[0]->mutable_cpu_data()[0] = loss / outer_num_;
  }
  if (top.size() == 2) {
    top[1]->ShareData(prob_);
  }
}

template <typename Dtype>
void WeightedSoftmaxWithLossLayer<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();
    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]);
        if (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[i * dim + label_value * inner_num_ + j] -= 1;
          Dtype w = (label_value == pos_cid_) ? pos_mult_ : 1;
          for (int k = 0; k < dim; ++k) {
            bottom_diff[i * dim + k * inner_num_ + j] *= w;
          }
          ++count;
        }
      }
    }
    // Scale gradient
    const Dtype loss_weight = top[0]->cpu_diff()[0];
    if (normalize_) {
      caffe_scal(prob_.count(), loss_weight / count, bottom_diff);
    } else {
      caffe_scal(prob_.count(), loss_weight / outer_num_, bottom_diff);
    }
  }
}


#ifdef CPU_ONLY
STUB_GPU(WeightedSoftmaxWithLossLayer);
#endif

INSTANTIATE_CLASS(WeightedSoftmaxWithLossLayer);
REGISTER_LAYER_CLASS(WeightedSoftmaxWithLoss);

}  // namespace caffe

cu:

#include <algorithm>
#include <cfloat>
#include <vector>

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

namespace caffe {

template <typename Dtype>
__global__ void WeightedSoftmaxLossForwardGPU(const int nthreads,
          const Dtype* prob_data, const Dtype* label, Dtype* loss,
	  const Dtype pos_mult_, const int pos_cid_,
          const int num, const int dim, const int spatial_dim,
          const bool has_ignore_label_, const int ignore_label_,
          Dtype* counts) {
  CUDA_KERNEL_LOOP(index, nthreads) {
    const int n = index / spatial_dim;
    const int s = index % spatial_dim;
    const int label_value = static_cast<int>(label[n * spatial_dim + s]);
    Dtype w = (label_value == pos_cid_) ? pos_mult_ : 1;
    if (has_ignore_label_ && label_value == ignore_label_) {
      loss[index] = 0;
      counts[index] = 0;
    } else {
      loss[index] = -w * log(max(prob_data[n * dim + label_value * spatial_dim + s],
                                 Dtype(FLT_MIN)));
      counts[index] = 1;
    }
  }
}

template <typename Dtype>
void WeightedSoftmaxWithLossLayer<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_;
  // Since this memory is not used for anything until it is overwritten
  // on the backward pass, we use it here to avoid having to allocate new GPU
  // memory to accumulate intermediate results in the kernel.
  Dtype* loss_data = bottom[0]->mutable_gpu_diff();
  // Similarly, this memory is never used elsewhere, and thus we can use it
  // to avoid having to allocate additional GPU memory.
  Dtype* counts = prob_.mutable_gpu_diff();
  // NOLINT_NEXT_LINE(whitespace/operators)
  WeightedSoftmaxLossForwardGPU<Dtype><<<CAFFE_GET_BLOCKS(nthreads),
      CAFFE_CUDA_NUM_THREADS>>>(nthreads, prob_data, label, loss_data,
      pos_mult_, pos_cid_, 
      outer_num_, dim, inner_num_, has_ignore_label_, ignore_label_, counts);
  Dtype loss;
  caffe_gpu_asum(nthreads, loss_data, &loss);
  if (normalize_) {
    Dtype count;
    caffe_gpu_asum(nthreads, counts, &count);
    loss /= count;
  } else {
    loss /= outer_num_;
  }
  top[0]->mutable_cpu_data()[0] = loss;
  if (top.size() == 2) {
    top[1]->ShareData(prob_);
  }
}

template <typename Dtype>
__global__ void WeightedSoftmaxLossBackwardGPU(const int nthreads, const Dtype* top,
          const Dtype* label, Dtype* bottom_diff, 
	  const Dtype pos_mult_, const int pos_cid_,
	  const int num, const int dim,
          const int spatial_dim, const bool has_ignore_label_,
          const int ignore_label_, Dtype* counts) {
  const int channels = dim / spatial_dim;

  CUDA_KERNEL_LOOP(index, nthreads) {
    const int n = index / spatial_dim;
    const int s = index % spatial_dim;
    const int label_value = static_cast<int>(label[n * spatial_dim + s]);
    Dtype w = (label_value == pos_cid_) ? pos_mult_ : 1;

    if (has_ignore_label_ && label_value == ignore_label_) {
      for (int c = 0; c < channels; ++c) {
        bottom_diff[n * dim + c * spatial_dim + s] = 0;
      }
      counts[index] = 0;
    } else {
      bottom_diff[n * dim + label_value * spatial_dim + s] -= 1;
      counts[index] = 1;
      for (int c = 0; c < channels; ++c) {
        bottom_diff[n * dim + c * spatial_dim + s] *= w;
      }
    }
  }
}

template <typename Dtype>
void WeightedSoftmaxWithLossLayer<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();
    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();
    // NOLINT_NEXT_LINE(whitespace/operators)
    WeightedSoftmaxLossBackwardGPU<Dtype><<<CAFFE_GET_BLOCKS(nthreads),
        CAFFE_CUDA_NUM_THREADS>>>(nthreads, top_data, label, bottom_diff,
	pos_mult_, pos_cid_,
        outer_num_, dim, inner_num_, has_ignore_label_, ignore_label_, counts);
    const Dtype loss_weight = top[0]->cpu_diff()[0];
    if (normalize_) {
      Dtype count;
      caffe_gpu_asum(nthreads, counts, &count);
      caffe_gpu_scal(prob_.count(), loss_weight / count, bottom_diff);
    } else {
      caffe_gpu_scal(prob_.count(), loss_weight / outer_num_, bottom_diff);
    }
  }
}

INSTANTIATE_LAYER_GPU_FUNCS(WeightedSoftmaxWithLossLayer);

}  // namespace caffe</span>

（4）在训练的prototxt文件中，按照下面方法使用（比如指定从0数起的第1类，权重加强，乘子为2.0）：

layer {
  name: "loss"
  type: "WeightedSoftmaxWithLoss"
  bottom: "fc_end"
  bottom: "label"
  top: "loss"
  softmax_param {
    pos_cid: 1
    pos_mult: 2.0
  }
}


未完待续。。。。。。。。。。

langb2014
关注
专栏目录
Caffe C++ WeightedSoftmaxWithLoss 实现
weixin_36588212的博客
05-11 282
List item Caffe C++ WeightedSoftmaxWithLoss 实现 参考 liaomingg的github 主要是caffe没有 weighted softmax with loss，需要使用的时候找不到，在此做个记录 1.首先是修改 caffe_3d/src/caffe/proto/caffe.proto，在SoftmaxParameter里添加如下两行 message SoftmaxParameter { ..... repeated float pos_mul.
卷积神经网络系列之softmax loss对输入的求导推导
AI之路
03-20 2万+
我们知道卷积神经网络（CNN）在图像领域的应用已经非常广泛了，一般一个CNN网络主要包含卷积层，池化层（pooling），全连接层，损失层等。虽然现在已经开源了很多深度学习框架（比如MxNet，Caffe等），训练一个模型变得非常简单，但是你对损失函数求梯度是怎么求的真的了解吗？相信很多人不一定清楚。虽然网上的资料很多，但是质量参差不齐，常常看得眼花缭乱。为了让大家少走弯路，特地整理了下这些知识点...
softmax loss
keep forward, go, go, go
07-04 1481
  softmax函数比较简单，可以用如下公式表示 同样，交叉熵的公式也很简单，如下： 其中 表示真实的概率（），而 表示预测的概率。 在深度学习中，这二者也经常被使用，softmax常被用来将输出映射到0~1的概率值，而cross entropy则常被用来作为分类模型的损失函数。 在使用的时候有什么需要注意的呢？ softmax存在下溢和上溢的问题，如果=c，那么softmax的值都...
Softmax函数
最新发布
杨航的专栏
08-06 434
在多分类问题中，每个类别都会得到一个在0到1之间的概率值，这些概率值的总和为1。在这个例子中，`softmax` 函数首先计算输入向量 `z` 中每个元素的指数，然后计算所有指数的和，最后用每个元素的指数除以这个和，得到每个类别的概率。使用 `stable_softmax` 函数代替之前的 `softmax` 函数可以避免在处理非常大数值时可能出现的数值不稳定问题。其中，\( e^{z_i} \) 是 \( z_i \) 的指数，分母是所有指数的和，确保了所有概率之和为1。# 计算所有指数的总和。
关于softmax loss这个概念
微电子学与固体电子学-俞驰
06-04 838
注意： 网上有很多softmax loss指的是：softmax layer with cross entropy loss. 但是： softmax layer with cross entropy loss≠cross entropy loss 因为cross entropy loss不仅仅可以用于softmax的输出端。 那么文献中有没有提到“softmax loss”，有的： <Co...
caffe中五种层的实现与参数配置（4）------softmax层
w_q_q2017的博客
01-27 972
Softmax回归模型是logistic回归模型在多分类问题上的推广，在多分类问题中，待分类的类别数量大于2，且类别之间互斥。 Softmax公式： 通常情况下softmax会被用在网络中的最后一层，用来进行最后的分类和归一化。 通常有2种结构： 第一种 #可以计算给出每个样本对应的损失函数值 layer { name: "loss" type: "SoftmaxWi
L2-constrained Softmax Loss for Discriminative Face Verification
chenaxin的博客
06-19 366
https://arxiv.org/abs/1703.09507 摘要   近年来，利用深度卷积神经网络(DCNNs)，人脸验证系统的性能得到了显著改善。一个典型的人脸验证流程包括:使用softmax loss训练一个用于目标分类的深度网络，使用倒数第二层输出作为特征描述子，对一组人脸图像生成余弦相似度评分。softmax loss函数没有优化特征，使正对相似度更高，负对相似度更低，这导致性能差异。在本文中，我们对特征描述符增加了一个L2约束，限制它们位于一个固定半径的超球面上。这个模块可以使用现有的深度学
Caffe官方教程中译本.pdf（高清非扫描）
04-05
3.1 Loss weights：在Caffe中，可以为不同的输出层设置不同的损失权重，影响梯度更新的强度。 四、求解器 求解器用于更新网络参数以最小化损失函数。 4.1 求解器简介：介绍了解决器的作用，如SGD（随机梯度下降）...
bvlc_reference_caffenet.caffemodel
03-18
Caffenet是对AlexNet网络结构的一种实现，AlexNet是由Alex Krizhevsky等人在2012年ImageNet Large Scale Visual Recognition Challenge (ILSVRC)中首次提出的。这个模型的成功标志着深度学习在图像识别领域的突破，...
caffe层解读系列-softmax_loss
爱吃鱼的猫
04-01 967
博文地址：http://blog.csdn.net/shuzfan/article/details/51460895 Loss Function softmax_loss的计算包含2步： （1）计算softmax归一化概率 （2）计算损失 这里以batchsize=1的2分类为例： 设最后一层的输出为[1.2 0
softmax,softmax loss 和cross entropy的讲解
Andyato的博客
03-18 1321
原文链接：http://blog.csdn.net/u014380165/article/details/77284921
Caffe loss 精讲
前进ing的博客
03-20 647
每一次训练迭代，都会向前传播，产生loss值。 Loss部分在solver文件中，有两个参数： 1. average_loss 默认值是1，Loss为单个iteration对应的loss； 当设置average_loss = n ， 则Loss为n个Loss的均值，相当于做个均值滤波。 2. weight_decay 为正则项在Loss函数中的系数。如果过拟合，调大这个参数；如果欠拟合...
解决Caffe训练过程中loss不变问题
热门推荐
炼丹
05-02 3万+
caffe中loss保持87.33和0.69的解决办法
caffe loss层
ziyouyi111的博客
06-29 827
在caffe中,默认的以loss结尾的layer可以作为loss层,但是中间的层同样可以作为loss层.原因是这样的:有一个和这个相关的参数:loss_weight,它决定了你的每个loss层占最好的loss的大小.在以loss结尾的layer里面, loss_wight的大小为1. 在不是以loss结尾的layer里面,它的loss_weight为0.layer { name: "loss"...
caffe（2）修改源代码添加loss(层)函数
weixin_42535423的博客
01-14 401
caffe（2）修改源代码添加loss函数第一步：在caffe.proto增加对应的LayerParameter message第二步：在./include/caffe/layers/下增加相应的layer的声明第三步：在./src/caffe/util/math_functions.cpp/下增加“绝对值求和”模板函数第四步：在./src/caffe/layers/下增加相应layer的CPU/...
梳理caffe代码loss（二十二）
人工智能
03-05 6355
下面是一个博友对于NG课程的翻译： 接下来偷懒一下直接上传图片，caffe中的常用的loss函数（后面文章会梳理每一个Loss）： loss有一个细节问题就是Loss weights（损失权重），用来表征不同Layer产生的loss的重要性，Layer名称中以Loss结尾表示这是一个会产生loss的La
ssd训练mbox_loss = 0
qq_43183413的博客
09-19 800
ssd训练mbox_loss = 0 Train net output #0: mbox_loss = 0一般是数据集出了问题， 即制作lmdb时出了错，网上公开数据集中xml文件坐标都是float浮点数，而caffe-ssd制作lmdb时，读坐标文件是读int整数型，所以回来的坐标全为0，故而会使得loss为0. 读写坐标文件是/caffe-ssd/src/caffe/utils/io.cpp...
深度学习——知识点总结3(损失函数Loss)
07-08 7792
Q：损失函数有几种？原理是什么？有什么特点？ 损失函数（loss function）是用来估量模型的预测值f(x)与真实值Y的不一致程度，它是一个非负实值函数,通常使用L(Y, f(x))来表示，损失函数越小，模型的鲁棒性就越好。损失函数是经验风险函数的核心部分，也是结构风险函数重要组成部分。模型的结构风险函数包括了经验风险项和正则项，通常可以表示成如下式子： 　　其中，前面的均值函数表示...
多分类svm的hinge loss公式推导_损失函数—深度学习常见损失函数总结【图像分类|下】...
weixin_39862097的博客
11-23 1293
点击蓝字关注我们AI研习图书馆，发现不一样的精彩世界学习笔记常见损失函数总结-图像分类下篇一、前言在深度学习中，损失函数扮演着至关重要的角色。通过最小化损失函数，使模型达到收敛状态，减少模型预测值的误差。因此，不同的损失函数，对模型的影响是十分重大的。接下来，重点总结一下在实习工作实践中经常用到的损失函数：图像分类：softmax，weighted softmax loss，focal ...
评论 31
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值