2. 程式人生 > >SSD網路解析之SmoothL1LossLayer層

SSD網路解析之SmoothL1LossLayer層

阿新 • • 發佈：2018-12-31

SSD網路中的SmoothL1LossLayer層借鑑於Fast R-CNN，用於計算smooth L1損失，其中的光滑L1函式如下：

                                                               smooth_{_{L1}}(x)=\left\{\begin{matrix} 0.5x^{^{2}}, |x|<1\\ |x|-0.5,|x|\geqslant 1 \end{matrix}\right.

其導函式為：

                                                                smooth_{L1}^{'}(x)=\left\{\begin{matrix} x,-1< x<1\\ 1,x\geqslant 1 \\ -1,x\leqslant -1 \end{matrix}\right.

之所以稱為光滑L1函式，是因為此函式處處可導，而原L1函式在x=0處是不可導的。

smooth L1損失為：

                                                                E=\frac{1}{N}\sum_{i=1}^{N}\sum_{j=1}^{k}smooth_{L1}(\hat{y}_{ij}-y_{ij})

其中y_{i}=[y_{i1},y_{i2},...,y_{ik}]^{T}為標籤向量;\hat{y}_{i}為預測向量。

在補充完上述了理論知識後，我們開始解析原始碼。

該層沒有單獨在caffe.proto中指定引數，其傳入的一些引數，如loss_weight均來自LayerParameter，大家自行參閱一下。

（1）smooth_L1_loss_layer.hpp標頭檔案

// ------------------------------------------------------------------
// Fast R-CNN
// copyright (c) 2015 Microsoft
// Licensed under The MIT License [see fast-rcnn/LICENSE for details]
// Written by Ross Girshick
// Modified by Wei Liu
// ------------------------------------------------------------------

#ifndef CAFFE_SMOOTH_L1_LOSS_LAYER_HPP_
#define CAFFE_SMOOTH_L1_LOSS_LAYER_HPP_

#include <vector>

#include "caffe/blob.hpp"
#include "caffe/layer.hpp"
#include "caffe/proto/caffe.pb.h"

#include "caffe/layers/loss_layer.hpp"

namespace caffe {

/**
 * @brief Computes the SmoothL1 loss as introduced in:@f$
 *  Fast R-CNN, Ross Girshick, ICCV 2015.
 */
template <typename Dtype>
class SmoothL1LossLayer : public LossLayer<Dtype> { //繼承於LossLayer
 public:
  explicit SmoothL1LossLayer(const LayerParameter& param)
      : LossLayer<Dtype>(param), diff_() {}
  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 "SmoothL1Loss"; }

  virtual inline int MinBottomBlobs() const { return 2; } //輸入blob最少為2個
  virtual inline int MaxBottomBlobs() const { return 3; } //輸入blob最多為3個

  /**
   * Unlike most loss layers, in the SmoothL1LossLayer we can backpropagate
   * to both inputs -- override to return true and always allow force_backward.
   */
  //這裡和caffe中的EuclideanLoss層一樣（兩個輸入blob都能進行反向傳播）
  //可參見https://blog.csdn.net/qq_21368481/article/details/81950538
  virtual inline bool AllowForceBackward(const int bottom_index) const {
    return true;
  }

 protected:
  /// @copydoc SmoothL1LossLayer
  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);

  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);

  Blob<Dtype> diff_;
  Blob<Dtype> errors_;
  bool has_weights_;
};

}  // namespace caffe

#endif  // CAFFE_SMOOTH_L1_LOSS_LAYER_HPP_

（2）CPU實現：smooth_L1_loss_layer.cpp

// ------------------------------------------------------------------
// Fast R-CNN
// copyright (c) 2015 Microsoft
// Licensed under The MIT License [see fast-rcnn/LICENSE for details]
// Written by Ross Girshick
// Modified by Wei Liu
// ------------------------------------------------------------------

#include <vector>

#include "caffe/layers/smooth_L1_loss_layer.hpp"
#include "caffe/util/math_functions.hpp"

namespace caffe {

template <typename Dtype>
void SmoothL1LossLayer<Dtype>::LayerSetUp(
  const vector<Blob<Dtype>*>& bottom, const vector<Blob<Dtype>*>& top) {
  LossLayer<Dtype>::LayerSetUp(bottom, top);
  has_weights_ = (bottom.size() == 3);  //是否有權重，其中bottom[2]儲存的是bottom[0]中每一元素在smoothL1損失函式中所佔的權重
}

template <typename Dtype>
void SmoothL1LossLayer<Dtype>::Reshape(
  const vector<Blob<Dtype>*>& bottom, const vector<Blob<Dtype>*>& top) {
  LossLayer<Dtype>::Reshape(bottom, top);
  //檢查bottom[0]和bottom[1]維度是不是一致
  CHECK_EQ(bottom[0]->channels(), bottom[1]->channels());
  CHECK_EQ(bottom[0]->height(), bottom[1]->height());
  CHECK_EQ(bottom[0]->width(), bottom[1]->width());
  if (has_weights_) { //檢查bottom[0]和bottom[2]維度是不是一致
    CHECK_EQ(bottom[0]->channels(), bottom[2]->channels());
    CHECK_EQ(bottom[0]->height(), bottom[2]->height());
    CHECK_EQ(bottom[0]->width(), bottom[2]->width());
  }
  //diff_,errors_的大小和bottom[0]大小一致
  diff_.Reshape(bottom[0]->num(), bottom[0]->channels(),
      bottom[0]->height(), bottom[0]->width());
  errors_.Reshape(bottom[0]->num(), bottom[0]->channels(),
      bottom[0]->height(), bottom[0]->width());
}

template <typename Dtype>
void SmoothL1LossLayer<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()); //caffe_sub()實現逐元素相減
  if (has_weights_) {
    caffe_mul(
        count,
        bottom[2]->cpu_data(),
        diff_.cpu_data(),
        diff_.mutable_cpu_data());  // d := w * (b0 - b1) caffe_mul()實現逐元素相乘
  }
  const Dtype* diff_data = diff_.cpu_data();
  Dtype* error_data = errors_.mutable_cpu_data();
  for (int i = 0; i < count; ++i) {
    Dtype val = diff_data[i];
    Dtype abs_val = fabs(val);
    //分段實現smoothL1損失的計算
    if (abs_val < 1.) {
      error_data[i] = 0.5 * val * val;
    } else {
      error_data[i] = abs_val - 0.5;
    }
  }
  top[0]->mutable_cpu_data()[0] =
      caffe_cpu_asum(count, errors_.cpu_data()) / bottom[0]->num(); //caffe_cpu_asum()計算所有元素的絕對值之和
}

template <typename Dtype>
void SmoothL1LossLayer<Dtype>::Backward_cpu(const vector<Blob<Dtype>*>& top,
    const vector<bool>& propagate_down, const vector<Blob<Dtype>*>& bottom) {
  int count = diff_.count();
  Dtype* diff_data = diff_.mutable_cpu_data();
  for (int i = 0; i < count; ++i) {
    Dtype val = diff_data[i];
    // f'(x) = x         if |x| < 1
    //       = sign(x)   otherwise
    if (fabs(val) < 1.) {
      diff_data[i] = val;
    } else {
      diff_data[i] = (Dtype(0) < val) - (val < Dtype(0)); //實現sign(x),即x>0時，sign(x)=1,x<0時，sign(x)=-1
    }
  }
  for (int i = 0; i < 2; ++i) {
    if (propagate_down[i]) {
      const Dtype sign = (i == 0) ? 1 : -1; //對應於兩個輸入blob，取不同的數值
      const Dtype alpha = sign * top[0]->cpu_diff()[0] / bottom[i]->num();
      //caffe_cpu_axpby實現b=alpha*a+beta*b（a和b均為向量）
      caffe_cpu_axpby(
          bottom[i]->count(),               // count
          alpha,                            // alpha
          diff_.cpu_data(),                 // a
          Dtype(0),                         // beta
          bottom[i]->mutable_cpu_diff());   // b
    }
  }
}

#ifdef CPU_ONLY
STUB_GPU(SmoothL1LossLayer);
#endif

INSTANTIATE_CLASS(SmoothL1LossLayer);
REGISTER_LAYER_CLASS(SmoothL1Loss);

}  // namespace caffe

其中的bottom[2]是權重，舉個例子如下：

                                                                                  y=\sum_{i=1}^{n}a_{i}smooth_{L1}(x_{i})

這裡的a_{i}組成的向量即為bottom[2]，而x_{i}=bottom[0](i)-bottom[1](i)。

從程式碼中也可以看出，損失函式的導數為：

當propagate_down[0] = true時，\frac{\partial E}{\partial \hat{y}_{ij}}=\left\{\begin{matrix} \frac{1}{N}(\hat{y}_{ij}-y_{ij}),|\hat{y}_{ij}-y_{ij}|<1\\ \frac{1}{N}sign(\hat{y}_{ij}-y_{ij}),otherwise \end{matrix}\right.

當propagate_down[1] = true時,\frac{\partial E}{\partial y_{ij}}=\left\{\begin{matrix} -\frac{1}{N}(\hat{y}_{ij}-y_{ij}),|\hat{y}_{ij}-y_{ij}|<1\\ -\frac{1}{N}sign(\hat{y}_{ij}-y_{ij}),otherwise \end{matrix}\right.

另外需要注意的是，這裡的兩個輸入blob都可以反向傳播的意思其實是該層可以允許預測值和標籤放反，即允許y_{ij}為預測向量，\hat{y}_{ij}為標籤向量，但需要設定propagate_down[1] = true或設定force_backward。

（3）GPU實現：smooth_L1_loss_layer.cu

// ------------------------------------------------------------------
// Fast R-CNN
// copyright (c) 2015 Microsoft
// Licensed under The MIT License [see fast-rcnn/LICENSE for details]
// Written by Ross Girshick
// Modified by Wei Liu
// ------------------------------------------------------------------

#include <vector>

#include "caffe/layers/smooth_L1_loss_layer.hpp"
#include "caffe/util/math_functions.hpp"

namespace caffe {
//計算smooth L1值
template <typename Dtype>
__global__ void SmoothL1Forward(const int n, const Dtype* in, Dtype* out) {
  // f(x) = 0.5 * x^2    if |x| < 1
  //        |x| - 0.5    otherwise
  CUDA_KERNEL_LOOP(index, n) {  //相當於for迴圈，只是是多執行緒的for迴圈
    Dtype val = in[index];
    Dtype abs_val = abs(val);
    if (abs_val < 1) {
      out[index] = 0.5 * val * val;
    } else {
      out[index] = abs_val - 0.5;
    }
  }
}

template <typename Dtype>
void SmoothL1LossLayer<Dtype>::Forward_gpu(const vector<Blob<Dtype>*>& bottom,
    const vector<Blob<Dtype>*>& top) {
  int count = bottom[0]->count();
  caffe_gpu_sub(
      count,
      bottom[0]->gpu_data(),
      bottom[1]->gpu_data(),
      diff_.mutable_gpu_data());    // d := b0 - b1
  if (has_weights_) {
    caffe_gpu_mul(
        count,
        bottom[2]->gpu_data(),
        diff_.gpu_data(),
        diff_.mutable_gpu_data());  // d := w * (b0 - b1)
  }
  // NOLINT_NEXT_LINE(whitespace/operators)
  SmoothL1Forward<Dtype><<<CAFFE_GET_BLOCKS(count), CAFFE_CUDA_NUM_THREADS>>>(
      count, diff_.gpu_data(), errors_.mutable_gpu_data());  //計算每一元素的smooth L1值
  CUDA_POST_KERNEL_CHECK;

  Dtype loss;
  caffe_gpu_asum(count, errors_.gpu_data(), &loss); //和caffe_cpu_asum實現一樣的功能
  top[0]->mutable_cpu_data()[0] = loss / bottom[0]->num(); //注意輸出blob呼叫的是cpu_data/cpu_diff(cpu和gpu的資料是同步的)
}

//計算smooth L1的導函式
template <typename Dtype>
__global__ void SmoothL1Backward(const int n, const Dtype* in, Dtype* out) {
  // f'(x) = x         if |x| < 1
  //       = sign(x)   otherwise
  CUDA_KERNEL_LOOP(index, n) {
    Dtype val = in[index];
    Dtype abs_val = abs(val);
    if (abs_val < 1) {
      out[index] = val;
    } else {
      out[index] = (Dtype(0) < val) - (val < Dtype(0));
    }
  }
}

template <typename Dtype>
void SmoothL1LossLayer<Dtype>::Backward_gpu(const vector<Blob<Dtype>*>& top,
    const vector<bool>& propagate_down, const vector<Blob<Dtype>*>& bottom) {
  int count = diff_.count();
  // NOLINT_NEXT_LINE(whitespace/operators)
  SmoothL1Backward<Dtype><<<CAFFE_GET_BLOCKS(count), CAFFE_CUDA_NUM_THREADS>>>(
      count, diff_.gpu_data(), diff_.mutable_gpu_data());
  CUDA_POST_KERNEL_CHECK;
  //計算損失函式的導數（梯度）
  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實現一樣的功能
      caffe_gpu_axpby(
          bottom[i]->count(),              // count
          alpha,                           // alpha
          diff_.gpu_data(),                // x
          Dtype(0),                        // beta
          bottom[i]->mutable_gpu_diff());  // y
    }
  }
}

INSTANTIATE_LAYER_GPU_FUNCS(SmoothL1LossLayer);

}  // namespace caffe

 

相關推薦

SSD網路解析之SmoothL1LossLayer層

SSD網路中的SmoothL1LossLayer層借鑑於Fast R-CNN，用於計算smooth L1損失，其中的光滑L1函式如下：              &n

SSD網路解析之MultiBoxLoss層

SSD網路中的MultiBoxLoss層是根據論文2.2節所提出的損失函式而寫的相應caffe實現，也是整個SSD網路很重要的部分。 首先，我們還是先來看一下論文原文對此部分的描述： ①英文部分 Training objective The SSD training objective

SSD網路解析之PriorBox層

SSD網路中的PriorBox層用於部署特徵圖中每個位置（畫素點）處的預設框（即計算每個預設框相對於網路輸入層輸入影象的歸一化左上角和右下角座標以及設定的座標variance值） 預設框的具體設定，我們需要先看一下原論文中的2.2節部分。 ①英文部分如下： Choosing scales

SSD網路解析之Permute層

Permute層是SSD（Single Shot MultiBox Detector）中用於置換索引軸順序的，與matlab中的permute()函式實現類似的功能，首先我們看一下caffe.proto中關於該層引數的說明： optional PermuteParameter permute_p

SSD網路解析之bbox_util

bbox_util.hpp檔案裡定義了SSD中好幾個層所需要用到的各種函式，bbox_util.cpp和bbox_util.cu檔案對應於這些函式的具體實現。 目錄 BBoxSize ClipBBox IsCrossBoundaryBBox JaccardOverlap En

網路程式設計之——七層模型與TCP三段握手與四次斷開

轉載請註明出處：https://blog.csdn.net/l1028386804/article/details/83046311 一、C/S架構 客戶端/服務端架構 二、OSI七層架構 七層模型，亦稱OSI（Open System Interconnection）參考模型，是

Python網路攻防之第二層攻擊 – Larry

本章節節選翻譯自《Understanding Network Hacks: Attack and Defense with Python》中的第四章Layer 2 Attacks。該書通過網路層次劃分介紹漏洞，並使用Python編寫相關利用工具進行網路攻防，每小節均按照“原理

python網路程式設計之——osi7層協議

每層執行常見的物理裝置 網際網路=物理連線介質+網際網路協議 應用層：http協議等等 自己定義 傳輸層：tcp/udp協議 應用軟體埠協議 網路層： IP協議+子網掩碼 arp協議：地址解析協議，根據ip解析mac地址 資料報：報頭+內容

安全的網路通道——網路准入之二層准入

安全是網路設計的永恆話題，網路攻擊與防護措施兩方，一直以來都在“魔高一尺，道高一丈”的迴圈螺旋式發展。進入雲端計算時代，網路安全的重要性更加突出，幾乎所有的雲端計算業務都不可能脫離嚴密的安全策略而獨立存在。 雲端計算強調資源請求與資源排程的分離，實際處理請求的後臺系統與發出請求的終端使用者之間是

Android網路協議之傳輸層

簡介 傳輸層是OSI中最重要，最關鍵的一層，時唯一負責總體的資料傳輸和資料控制的一層，傳輸層提供端到端的交換資料的機制，傳輸層對會話層等高三層提供可靠的傳輸服務，對網路層提供可靠的目的地的站定資訊 傳輸層也稱為運輸層，傳輸層只存在於端開發系統中，是介於低

linux網路基礎之三層交換機筆記

        1： 三層交換機可以解決單臂路由流量瓶頸問題，主要通過一次路由多次交換來完成。         2： 三層交換機原理：通過路由表查詢一次，以後記錄該mac地址和目的mac地址，形成一個路由表和arp表的對映關係，以後再次在不同的VLAN之間交換的時候直接通

計算機網路總結之運輸層

運輸層 （1），基本術語 程序（process）： 指計算機中正在執行的程式實體 應用程序互相通訊： 一臺主機的程序和另一臺主機中的一個程序交換資料的過程（另外注意通訊真正的端點不是主機而是主機中的程序，也就是說端到端的通訊是應用程序之間的通訊

神經網路入門之隱藏層設計

隱藏層 這部分教程將介紹三部分： 隱藏層設計非線性啟用函式BP演算法 在前面幾個教程中，我們已經介紹了一些很簡單的教程，就是單一的迴歸模型或者分類模型。在這個教程中，我們也將設計一個二分類神經網路模型，其中輸入資料是一個維度，隱藏層只有一個神經元，並且使用非線性函式作為

計算機網絡之物理層解析：

hostname show 出廠 路由器 問題 放大器 version bold -c 物理層是TCP/IP模型的最底層物理層功能：功能一 為數據端設備提供發送數據的通路功能二 傳輸數據物理層主要關心的問題是：信號、接口、傳輸介質。信號分為：模擬信號和數字信號模擬信號是信號

Android技能樹 — 網路小結之 OkHttp超超超超超超超詳細解析

前言： 本文也做了一次標題黨，哈哈，其實寫的還是很水，各位原諒我O(∩_∩)O。 介於自己的網路方面知識爛的一塌糊塗，所以準備寫相關網路的文章，但是考慮全部寫在一篇太長了，所以分開寫，希望大家能仔細看，最好可以指出我的錯誤，讓我也能糾正。 1.講解相關的整個網路體系結構： 網路體系結構小結 2.講解

CVPR2018論文解析之《Fully Convolutional Adaptation Networks for Semantic Segmentation》(全卷積適配網路)

論文網址：Fully Convolutional Adaptation Networks for Semantic Segmentation   1.摘要： 問題： 收集大量畫素級標記的資料是一個費事費力的過程，一個比較好的選擇是使用合成數據，比如遊戲視訊，來自動產生標籤。

計算機網路之五層體系結構

計算機各層網路協議 協議資料單元PDU（Protocol Data Unit）是指對等層次之間傳遞的資料單位 物理層 典型裝置：中繼器、集線器 使用了光纖、 同軸電纜、雙絞線…… 中間裝置：中繼器、集線器 中繼器     中繼器（Repe

計算機網路之傳輸層

前言 傳輸層是面向通訊部分的最頂層，是面向應用的最底層。面向通訊部分，距離傳輸層最近的網路層，因此本文會將傳輸層與網路層在必要時候進行對比。 傳輸層作用： 網路層提供的是主機之間的邏輯通訊，而傳輸層提供的是通訊雙方的程序之間的邏輯通訊。傳輸層為應用遮蔽了底層複雜的網

Volley 原始碼解析之網路請求

Volley 是 Google 推出的一款網路通訊框架，非常適合資料量小、通訊頻繁的網路請求，支援併發、快取和容易擴充套件、除錯等；不過不太適合下載大檔案、大量資料的網路請求，因為volley在解析期間將響應放到記憶體中，我們可以使用okhttp或者系統提供的DownloadManager來下載檔案。

藍芽檔案傳輸之obex層之上的分析【Android原始碼解析】

 在上節中我們仔細分析了藍芽檔案傳輸過程中涉及到的UI介面，最終定格在藍芽裝置掃描的介面，我們只要選擇自己想要傳輸的藍芽裝置就可以進行藍芽檔案的傳輸了。那就是這樣一個簡單的裝置選擇的點選會引發哪些