17.3.9 caffe自定義一個Layer會遇到的一些理解方面的問題
阿新 • • 發佈：2019-01-30
對於一個新手而言，在想要自己定義一個層的時候，常常會遇到許多理解方面的障礙。
首先，在瞭解具體的Layer的hpp和cpp檔案的內容之前，應該首先了解一下其在該Layer在/src/caffe/proto/caffe.proto檔案中的引數定義。
message CenterLossParameter {
optional uint32 num_output = 1; // The number of outputs for the layer
optional FillerParameter center_filler = 2; // The filler for the centers
// The first axis to be 從上面的程式碼中可以看出，在centerloss層中包含三個引數： num_output，center_filler和axis引數。num_output表示的輸出的個數。center_filler表示的是用來存放中心點的filler。 axis表示選取哪個維度資訊。一個常見的blob資料包括（N，C，H，W）四個維度，可以通過設定axis來選取哪一個維度。如果輸入影象的維度是(N, C, H, W)，則選取C * H * W 。
在瞭解了引數的定義之後，應該開始對hpp檔案進行閱讀，先了解該Layer包括哪些功能。hpp檔案一般出現在/include/caffe/layers/裡面。一些標頭檔案的包含暫且不考慮。
namespace caffe {
template <typename Dtype>
class CenterLossLayer : public LossLayer<Dtype> {
public:
explicit CenterLossLayer(const LayerParameter& param)
: LossLayer<Dtype>(param) {}
virtual void LayerSetUp(const vector<Blob<Dtype>*>& bottom,
const 從程式碼中可以看出，對於一個loss層而言，應該包括Setup（），Forward_cpu（），Forward_gpu（），Backward_cpu（）， Backward_gpu（）。
在宣告內還包括幾個inline函式，第一個是返回層的型別的字串。後面兩個分別表示輸入和輸出的個數。centerloss表示有2個輸入，無輸出。
除了上面的幾個，centerloss層還定義了Reshape（）和幾個變數。幾個變數通過對cpp檔案的閱讀了解到其對應的含義：
矩陣乘法引數(M, K) * (K, N) = (M, N)
M_ : 表示樣本的個數
K_ ： 表示單個特徵輸入的長度
N_ : 表示輸出神經元的個數
distance_ ： 表示誤差
variation_sum_ : 表示變數的總數
在理解了centerloss層主要包括的功能後就是其具體函式的功能。對應的cpp檔案在/src/caffe/layers/中。包含的標頭檔案暫時不考慮。
namespace caffe {
template <typename Dtype>
void CenterLossLayer<Dtype>::LayerSetUp(const vector<Blob<Dtype>*>& bottom,
const vector<Blob<Dtype>*>& top) {
const int num_output = this->layer_param_.center_loss_param().num_output();
N_ = num_output;
const int axis = bottom[0]->CanonicalAxisIndex(
this->layer_param_.center_loss_param().axis());
// Dimensions starting from "axis" are "flattened" into a single
// length K_ vector. For example, if bottom[0]'s shape is (N, C, H, W),
// and axis == 1, N inner products with dimension CHW are performed.
K_ = bottom[0]->count(axis);
// Check if we need to set up the weights
if (this->blobs_.size() > 0) {
LOG(INFO) << "Skipping parameter initialization";
} else {
this->blobs_.resize(1);
// Intialize the weight
vector<int> center_shape(2);
center_shape[0] = N_;
center_shape[1] = K_;
this->blobs_[0].reset(new Blob<Dtype>(center_shape));
// fill the weights
shared_ptr<Filler<Dtype> > center_filler(GetFiller<Dtype>(
this->layer_param_.center_loss_param().center_filler()));
center_filler->Fill(this->blobs_[0].get());
} // parameter initialization
this->param_propagate_down_.resize(this->blobs_.size(), true);
}
template <typename Dtype>
void CenterLossLayer<Dtype>::Reshape(const vector<Blob<Dtype>*>& bottom,
const vector<Blob<Dtype>*>& top) {
CHECK_EQ(bottom[1]->channels(), 1);
CHECK_EQ(bottom[1]->height(), 1);
CHECK_EQ(bottom[1]->width(), 1);
M_ = bottom[0]->num();
// The top shape will be the bottom shape with the flattened axes dropped,
// and replaced by a single axis with dimension num_output (N_).
LossLayer<Dtype>::Reshape(bottom, top);
distance_.ReshapeLike(*bottom[0]);
variation_sum_.ReshapeLike(*this->blobs_[0]);
}
template <typename Dtype>
void CenterLossLayer<Dtype>::Forward_cpu(const vector<Blob<Dtype>*>& bottom,
const vector<Blob<Dtype>*>& top) {
const Dtype* bottom_data = bottom[0]->cpu_data();
const Dtype* label = bottom[1]->cpu_data();
const Dtype* center = this->blobs_[0]->cpu_data();
Dtype* distance_data = distance_.mutable_cpu_data();
// the i-th distance_data
for (int i = 0; i < M_; i++) {
const int label_value = static_cast<int>(label[i]);
// D(i,:) = X(i,:) - C(y(i),:)
caffe_sub(K_, bottom_data + i * K_, center + label_value * K_, distance_data + i * K_);
}
Dtype dot = caffe_cpu_dot(M_ * K_, distance_.cpu_data(), distance_.cpu_data());
Dtype loss = dot / M_ / Dtype(2);
top[0]->mutable_cpu_data()[0] = loss;
}
template <typename Dtype>
void CenterLossLayer<Dtype>::Backward_cpu(const vector<Blob<Dtype>*>& top,
const vector<bool>& propagate_down,
const vector<Blob<Dtype>*>& bottom) {
// Gradient with respect to centers
if (this->param_propagate_down_[0]) {
const Dtype* label = bottom[1]->cpu_data();
Dtype* center_diff = this->blobs_[0]->mutable_cpu_diff();
Dtype* variation_sum_data = variation_sum_.mutable_cpu_data();
const Dtype* distance_data = distance_.cpu_data();
// \sum_{y_i==j}
caffe_set(N_ * K_, (Dtype)0., variation_sum_.mutable_cpu_data());
for (int n = 0; n < N_; n++) {
int count = 0;
for (int m = 0; m < M_; m++) {
const int label_value = static_cast<int>(label[m]);
if (label_value == n) {
count++;
caffe_sub(K_, variation_sum_data + n * K_, distance_data + m * K_, variation_sum_data + n * K_);
}
}
caffe_axpy(K_, (Dtype)1./(count + (Dtype)1.), variation_sum_data + n * K_, center_diff + n * K_);
}
}
// Gradient with respect to bottom data
if (propagate_down[0]) {
caffe_copy(M_ * K_, distance_.cpu_data(), bottom[0]->mutable_cpu_diff());
caffe_scal(M_ * K_, top[0]->cpu_diff()[0] / M_, bottom[0]->mutable_cpu_diff());
}
if (propagate_down[1]) {
LOG(FATAL) << this->type()
<< " Layer cannot backpropagate to label inputs.";
}
}
#ifdef CPU_ONLY
STUB_GPU(CenterLossLayer);
#endif
INSTANTIATE_CLASS(CenterLossLayer);
REGISTER_LAYER_CLASS(CenterLoss);
} // namespace caffe首先對於Setup（）函式：在該函式中主要包括了對centerloss層的引數的獲取以及處理。首先N_表示num_output，K_表示axis對應的維度的長度。然後是權重的初始化問題。最後獲取center_filler引數的值。
緊接著進行引數初始化。
在引數初始化之後，就是對前向和後向傳播的理解。前向傳播比較好些，主要的難點在於後向傳播。
未完待續！