add cpu forward and backward implementation in smooth_l1_loss_layer.c…

…pp as rbgirshick/caffe-fast-rcnn#17
ZhuLingfeng1993 · Dec 27, 2018 · e16df50 · e16df50
1 parent 9d406c4
commit e16df50
Showing 1 changed file with 91 additions and 2 deletions.
diff --git a/src/caffe/layers/smooth_l1_loss_layer.cpp b/src/caffe/layers/smooth_l1_loss_layer.cpp
@@ -46,13 +46,102 @@ void SmoothL1LossLayer<Dtype>::Reshape(
 template <typename Dtype>
 void SmoothL1LossLayer<Dtype>::Forward_cpu(const vector<Blob<Dtype>*>& bottom,
     const vector<Blob<Dtype>*>& top) {
-  NOT_IMPLEMENTED;
+  int count = bottom[0]->count();
+  caffe_sub(
+      count,
+      bottom[0]->cpu_data(),
+      bottom[1]->cpu_data(),
+      diff_.mutable_cpu_data());    // d := b0 - b1
+  if (has_weights_) {
+    // apply "inside" weights
+    caffe_mul(
+        count,
+        bottom[2]->cpu_data(),
+        diff_.cpu_data(),
+        diff_.mutable_cpu_data());  // d := w_in * (b0 - b1)
+  }
+
+  // f(x) = 0.5 * (sigma * x)^2          if |x| < 1 / sigma / sigma
+  //        |x| - 0.5 / sigma / sigma    otherwise
+  const Dtype* in = diff_.cpu_data();
+  Dtype* out = errors_.mutable_cpu_data();
+
+#ifdef _OPENMP
+#pragma omp parallel for
+#endif
+  for (int index = 0; index < count; ++index) {
+    Dtype val = in[index];
+    Dtype abs_val = fabs(val);
+    if (abs_val < 1.0 / sigma2_) {
+      out[index] = 0.5 * val * val * sigma2_;
+    } else {
+      out[index] = abs_val - 0.5 / sigma2_;
+    }
+  }
+
+  if (has_weights_) {
+    // apply "outside" weights
+    caffe_mul(
+        count,
+        bottom[3]->cpu_data(),
+        errors_.cpu_data(),
+        errors_.mutable_cpu_data());  // d := w_out * SmoothL1(w_in * (b0 - b1))
+  }
+
+  Dtype loss = caffe_cpu_dot(count, ones_.cpu_data(), errors_.cpu_data());
+  top[0]->mutable_cpu_data()[0] = loss / bottom[0]->num();
 }
 
 template <typename Dtype>
 void SmoothL1LossLayer<Dtype>::Backward_cpu(const vector<Blob<Dtype>*>& top,
     const vector<bool>& propagate_down, const vector<Blob<Dtype>*>& bottom) {
-  NOT_IMPLEMENTED;
+  // after forwards, diff_ holds w_in * (b0 - b1)
+  int count = diff_.count();
+
+  // f'(x) = sigma * sigma * x         if |x| < 1 / sigma / sigma
+  //       = sign(x)                   otherwise
+  const Dtype* in = diff_.cpu_data();
+  Dtype* out = diff_.mutable_cpu_data();
+
+#ifdef _OPENMP
+#pragma omp parallel for
+#endif
+  for (int index = 0; index < count; ++index) {
+      Dtype val = in[index];
+      Dtype abs_val = fabs(val);
+      if (abs_val < 1.0 / sigma2_) {
+        out[index] = sigma2_ * val;
+      } else {
+        out[index] = (Dtype(0) < val) - (val < Dtype(0));
+      }
+  }
+
+  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(
+          count,                           // count
+          alpha,                           // alpha
+          diff_.cpu_data(),                // x
+          Dtype(0),                        // beta
+          bottom[i]->mutable_cpu_diff());  // y
+      if (has_weights_) {
+        // Scale by "inside" weight
+        caffe_mul(
+            count,
+            bottom[2]->cpu_data(),
+            bottom[i]->cpu_diff(),
+            bottom[i]->mutable_cpu_diff());
+        // Scale by "outside" weight
+        caffe_mul(
+            count,
+            bottom[3]->cpu_data(),
+            bottom[i]->cpu_diff(),
+            bottom[i]->mutable_cpu_diff());
+      }
+    }
+  }
 }
 
 #ifdef CPU_ONLY