文章首發于微信公眾號《與有三學AI》

[caffe解讀] caffe從數學公式到代碼實現4-認識caffe自帶的7大lossz

本節說caffe中常見loss的推導，具體包含下面的cpp。

multinomial_logistic_loss_layer.cpp
softmax_loss_layer.cpp
euclidean_loss_layer.cpp
sigmoid_cross_entropy_loss_layer.cpp
contrastive_loss_layer.cpp
hinge_loss_layer.cpp
infogain_loss_layer.cpp

?

01 multinomial_logistic_loss_layer.cpp

數學定義

x是輸入，y是label，l是loss

上述式只有當樣本i屬于第k類時，y?k=1，其他情況?y?k=0，我們計不為0的?y?k=y。

forward?&?backward

forward對所有求和，注意此處沒有對圖像維度的像素進行歸一化，只對batch?size維度進行歸一化，num就是batchsize，這與下面的softmaxlosslayer是不一樣的。

voidMultinomialLogisticLossLayer<Dtype>::Forward_cpu(
const?vector<Blob<Dtype>*>&?bottom,?constvector<Blob<Dtype>*>&?top)?{
const?Dtype*?bottom_data?=?bottom[0]->cpu_data();
const?Dtype*?bottom_label?=?bottom[1]->cpu_data();
int?num?=?bottom[0]->num();
int?dim?=?bottom[0]->count()?/?bottom[0]->num();
Dtype?loss?=?0;
for?(int?i?=?0;?i?<?num;?++i)?{
int?label?=?static_cast<int>(bottom_label[i]);
Dtype?prob?=?std::max(?bottom_data[i?*?dim?+?label],Dtype(kLOG_THRESHOLD));
loss?-=?log(prob);
}
top[0]->mutable_cpu_data()[0]?=?loss?/?num;
}

backward可以自己去看，很簡單就不說了

?

02 softmax_layer.cpp

數學定義

softmax是我們最熟悉的了，分類任務中使用它，分割任務中依然使用它。Softmax?loss實際上是由softmax和cross-entropy?loss組合而成，兩者放一起數值計算更加穩定。

令z是softmax_with_loss層的輸入，f(z)是softmax的輸出，則

單個像素i的softmax?loss等于cross-entropy?error如下

展開上式：

在網絡中，z是即bottom?blob，l(y,z)是top?blob,反向傳播時就是要根據top?blob?diff得到bottom?blob?diff，所以要得到?

下面求loss對z的第k個節點的梯度

可見，傳給groundtruth?label節點和非groundtruth?label是的梯度是不一樣的。

forward就不看了，看看backward吧。

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;
++count;
}
}
}

Test_softmax_with_loss_layer.cpp

作為loss層，很有必要測試一下，測試也分兩塊，forward和backward。

Forward測試是這樣的，定義了個bottom?blob?data和bottom?blob?label，給data塞入高斯分布數據，給label塞入0～4。

blob_bottom_data_(new
Blob<Dtype>(10,?5,?2,?3)),
blob_bottom_label_(new
Blob<Dtype>(10,?1,?2,?3)),

然后分別ingore其中的一個label做5次，最后比較，代碼如下。

Dtype?accum_loss?=?0;
for?(int?label?=?0;?label?<?5;?++label)?{
layer_param.mutable_loss_param()->set_ignore_label(label);
layer.reset(new?SoftmaxWithLossLayer<Dtype>(layer_param));
layer->SetUp(this->blob_bottom_vec_,
this->blob_top_vec_);
layer->Forward(this->blob_bottom_vec_,?this->blob_top_vec_);
accum_loss?+=?this->blob_top_loss_->cpu_data()[0];
}
//?Check?that?each?label?was?included?all?but
once.
EXPECT_NEAR(4?*?full_loss,?accum_loss,?1e-4);

至于backwards，直接套用checker.CheckGradientExhaustive就行，它自己會利用數值微分的方法和你寫的backwards來比較精度。

TYPED_TEST(SoftmaxWithLossLayerTest,
TestGradientIgnoreLabel)?{
typedef?typename?TypeParam::Dtype?Dtype;
LayerParameter?layer_param;
//
labels?are?in?{0,?...,?4},?so?we'll?ignore?about?a?fifth?ofthem
layer_param.mutable_loss_param()->set_ignore_label(0);
SoftmaxWithLossLayer<Dtype>?layer(layer_param);
GradientChecker<Dtype>?checker(1e-2,?1e-2,?1701);
checker.CheckGradientExhaustive(&layer,?this->blob_bottom_vec_,
this->blob_top_vec_,?0);
}

?

03 eulidean_loss_layer.cpp

euclidean?loss就是定位檢測任務中常用的loss。

數學定義：

forward?&?backward

voidEuclideanLossLayer<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
}
}
}

testcpp就不說了。

?

04 sigmoid_cross_entropy_loss_layer.cpp

與softmax?loss的應用場景不同，這個loss不是用來分類的，而是用于預測概率，所以在loss中，沒有類別的累加項。

令第i個節點輸入Xi?，輸出總loss為l，label為?yi?，則loss定義如下

其中

上式子有個等價轉換，這是為了更好的理解caffe?中forward的計算，公式太多我就直接借用了，如果遇到了原作者請通知我添加轉載申明。

http://blog.csdn.net/u012235274/article/details/51361290

反向求導公式如下：

在經過上面的轉換后，避開了數值計算不穩定的情況，caffe中的源碼是對整個的bottom[0]->count進行計算累加的，沒有區分label項。

for?(int?i?=?0;?i?<?bottom[0]->count();?++i)?{
const?int?target_value?=?static_cast<int>(target[i]);
if?(has_ignore_label_?&&?target_value?==ignore_label_)?{
continue;
}
loss?-=?input_data[i]?*?(target[i]?-?(input_data[i]?>=0))?-?log(1?+?exp(input_data[i]?-?2?*?input_data[i]?*(input_data[i]?>=?0)));
++valid_count;
}

反向傳播很簡單就不看了

?

05 contrastive_loss_layer.cpp

有一類網絡叫siamese?network，它的輸入是成對的。比如輸入兩張大小相同的圖，網絡輸出計算其是否匹配。所采用的損失函數就是contrastive?loss

數學定義：

d就是歐氏距離，y是標簽，如果兩個樣本匹配，則為1，否則為0.?當y=1，loss就是歐氏距離，說明匹配的樣本距離越大，loss越大。當y=0，就是與閾值margin的歐式距離，說明不匹配的樣本，歐氏距離應該越大越好，超過閾值最好，loss就等于0.

反向傳播其實就是分y=1和y=0兩種情況下的euclidean?loss的反向傳導，由于與euclidean
loss非常相似，不再贅述。

?

06 hinge_loss_layer.cpp

這是一個多分類的loss,?也是SVM的目標函數，沒有學習參數的全連接層InnerProductLayer+HingeLossLayer就等價于SVM。

數學定義:

這個層的輸入bottom[0]是一個N*C*H*W的blob，其中取值任意值，label就是N*1*1*1，其中存儲的就是整型的label{0,1,2,…,k}。tnk??相當于SVM中的 XTW

參考博客http://blog.leanote.com/post/braveapple/Hinge-Loss-%E7%9A%84%E7%90%86%E8%A7%A3

假如預測類別數是K個，正確的label是M，預測值為tnk，即是第n個樣本對第k類的預測值，那么當k=M時。

當k!=M時

其中p=1，p=2分別對應L1范數和L2范數，以L1為例

Forward

caffe_copy(count,?bottom_data,?bottom_diff);
for?(int?i?=?0;?i?<?num;?++i)?{?bottom_diff[i?*?dim?+static_cast<int>(label[i])]?*=?-1;
}
for?(int?i?=?0;?i?<?num;?++i)?{
for?(int?j?=?0;?j?<?dim;?++j)?{
bottom_diff[i?*?dim?+?j]?=?std::max(?Dtype(0),?1?+bottom_diff[i?*?dim?+?j]);
}
}
Dtype*?loss?=?top[0]->mutable_cpu_data();
switch?(this->layer_param_.hinge_loss_param().norm())?{
case?HingeLossParameter_Norm_L1:
loss[0]?=?caffe_cpu_asum(count,?bottom_diff)?/?num;break;
case?HingeLossParameter_Norm_L2:
loss[0]?=?caffe_cpu_dot(count,?bottom_diff,bottom_diff)?/?num;?break;
default:?LOG(FATAL)?<<?"Unknown?Norm";
}

只需要根據上面的轉化后的式子，在正確label處乘以-1，然后累加即可。

再看反向梯度求導：

當進行一次forward之后，

bottom_diff=[max(0,1+t0),max(0,1+t1),...,max(0,1?tk),...,max(0,1?tK-1)]

我們現在要求梯度，期望是1+tk>0時為1，1-tk>0時為-1，其他情況為0，

當任意一項1+tk或者1-tk<0時，會有梯度=0。實際上就是求上面向量各自元素的符號，當1+tk>0，sign(1+tk)，只是max(0,1?tk)這個應該反過來，當1-tk>0時，sign(tk-1)=-1。

代碼如下：

Dtype*?bottom_diff?=?bottom[0]->mutable_cpu_diff();
const?Dtype*?label?=?bottom[1]->cpu_data();
int?num?=?bottom[0]->num();
int?count?=?bottom[0]->count();
int?dim?=?count?/?num;
for?(int?i?=?0;?i?<?num;?++i)?{
bottom_diff[i?*?dim?+?static_cast<int>(label[i])]?*=?-1;
}
const?Dtype?loss_weight?=?top[0]->cpu_diff()[0];
switch?(this->layer_param_.hinge_loss_param().norm())?{
case?HingeLossParameter_Norm_L1:
caffe_cpu_sign(count,?bottom_diff,?bottom_diff);
caffe_scal(count,?loss_weight?/?num,?bottom_diff);?
break;
case?HingeLossParameter_Norm_L2:
caffe_scal(count,?loss_weight?*?2?/?num,?bottom_diff);
break;
default:?LOG(FATAL)?<<?"Unknown?Norm";
}

}

?

07 infogain_loss_layer.cpp

數學定義：

輸入bottom_data是N*C*H*W維向量，bottom_label是N*1*1*1維向量，存儲的就是類別數。它還有個可選的bottom[2]，是一個infogain?matrix矩陣,它的維度等于num_of_label?*?num_of_label。每個通道c預測的是第c類的概率，取值0～1，所有c個通道的概率相加=1。是不是像softMax？

實際上它內部就定義了shared_ptr<Layer<Dtype>?>softmax_layer_，用于映射輸入。

Loss定義如下：

其中Hln代表H的第ln行，K是所有類別數，如果H是一個單位矩陣，那么只有對角線有值，回到文章開頭，這就是multinomial_logistic_loss_layer。當H是一個普通矩陣時，當groundtruth?label為k，?

?時，值也可以非零。這樣各個類別之間就不存在競爭關系了，后來的mask-rcnn中實際上loss也就是去除了這重競爭關系。

Forward：

void?InfogainLossLayer<Dtype>::Forward_cpu(constvector<Blob<Dtype>*>&?bottom,
const?vector<Blob<Dtype>*>&?top)?{
softmax_layer_->Forward(softmax_bottom_vec_,softmax_top_vec_);
const?Dtype*?prob_data?=?prob_.cpu_data();
const?Dtype*?bottom_label?=?bottom[1]->cpu_data();
const?Dtype*?infogain_mat?=?NULL;
if?(bottom.size()?<?3)?{?infogain_mat?=infogain_.cpu_data();
}?else?{?infogain_mat?=?bottom[2]->cpu_data();}
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>(bottom_label[i?*?inner_num_?+?j]);
if?(has_ignore_label_?&&?label_value?==ignore_label_)?{continue;}
DCHECK_GE(label_value,?0);
DCHECK_LT(label_value,?num_labels_);
for?(int?l?=?0;?l?<?num_labels_;?l++)
{??loss?-=?infogain_mat[label_value?*?num_labels_?+?l]*?log(std::max(?prob_data[i?*inner_num_*num_labels_?+?l?*?inner_num_?+?j],
Dtype(kLOG_THRESHOLD)));}
++count;?}?}
top[0]->mutable_cpu_data()[0]?=?loss?/get_normalizer(normalization_,?count);
if?(top.size()?==?2)?{?top[1]->ShareData(prob_);?}}

上面與multinomial_logistic_loss_layer的區別就在于每一項乘了infogain_mat[label_value?*??num_labels_?+?l]。

Backward:

for?(int?l?=?0;?l?<?num_labels_;?++l)?{
???bottom_diff[i?*?dim?+?l?*?inner_num_?+?j]?=prob_data[i*dim?+?l*inner_num_?+j]*sum_rows_H[label_value]?-infogain_mat[label_value?*?num_labels_?+?l];
??}

這個，看了4篇了大家不妨自己推一推？不行咱再一起來

同時，在我的知乎專欄也會開始同步更新這個模塊，歡迎來交流

https://zhuanlan.zhihu.com/c_151876233

注：部分圖片來自網絡

—END—

打一個小廣告，我在gitchat開設了一些課程和chat，歡迎交流。

感謝各位看官的耐心閱讀，不足之處希望多多指教。后續內容將會不定期奉上，歡迎大家關注有三公眾號 有三AI！

?

總結

以上是生活随笔為你收集整理的【caffe解读】 caffe从数学公式到代码实现4-认识caffe自带的7大loss的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。