Caffe 损失层实现反向传播

机器学习

---

Caffe 以 loss_layer 为基类，派生各种损失层：

• Contrastive loss
• Euclidean loss
• Hinge loss
• Infogain loss
• Multinomial logistic loss
• Sigmoid cross entropy loss
• Softmax loss

通常不需要实现神经元层，只需要实现 data_layer 和 loss_layer。loss_layer 的实现简单一些，但是要考虑一些微积分求导数问题。

反向传播的数学形式定义为：

$$\frac{\partial J}{\partial W_{ij}} = \frac{\partial J}{\partial a_j}\ \times \frac{\partial a_j}{\partial z_j} \times \frac{\partial z_j}{\partial w_{ij}}$$
其中：
$$\frac{\partial J}{\partial a_j} = \sum_{k=1}^l \frac{\partial J}{\partial a_k} \times \frac{\partial a_k}{\partial z_k} \times \frac{\partial z_k}{\partial a_j}$$
显然 $\frac{\partial z_k}{\partial a_j} = w_{jk}$。至此，理论上可反向计算梯度。

定义:

$$\sigma_{j} = \frac{\partial J}{\partial a_j} \times \frac{\partial a_j}{\partial z_j},$$
$$\sigma_{j} = \sum_{k=1}^l (\sigma_k \times \frac{\partial z_k}{\partial a_j}) \times \frac{\partial a_j}{\partial z_j},$$
$$\frac{\partial J}{\partial W_{ij}} = \sigma_j \times \frac{\partial z_j}{\partial w_{ij}}.$$
引入中间变量 $\sigma$ 减少计算量，这实在非常有用。

回到 Caffe，在 Caffe 的 loss_layer，你必须计算其 $\frac{\partial J}{\partial y}$。在 Caffe 中损失计算如下：

template <typename Dtype>
void EuclideanLossLayer<Dtype>::Forward_cpu(const vector<Blob<Dtype>*>& bottom,
    const vector<Blob<Dtype>*>& top) {
  int count = bottom[0]->count();
  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;
}

Forward_cpu 比较简单，没有太多可说的。关键是反向的实现：

template <typename Dtype>
void EuclideanLossLayer<Dtype>::Backward_cpu(const vector<Blob<Dtype>*>& top,
    const vector<bool>& propagate_down, const vector<Blob<Dtype>*>& bottom) {
  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
    }
  }
}

恩，稍微不那么直观，则表示的含义是：

$$\frac{\partial J}{\partial y} = \frac{ (y - t) * \alpha}{N} ,$$
也就是计算损失对于神经网络输出（层的输入）的导数。

大体上，Caffe 的反向实现便是如此。称不上神秘；但是贾杨清的思路如此清晰，确实非常厉害。但是还是存在一些疑问，没读过神经元层的实现，对反向整体实现过程还有不解，不过暂时可以实现损失层了，哈哈。