hzxie
commented
5 years ago chamfer_distance_loss_layer.hpp
#ifndef CAFFE_CHAMFER_DISTANCE_LAYER_HPP_
#define CAFFE_CHAMFER_DISTANCE_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 {
template <typename Dtype>
class ChamferDistanceLossLayer : public LossLayer<Dtype> {
public:
explicit ChamferDistanceLossLayer(const LayerParameter& param)
: LossLayer<Dtype>(param) {}
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 "ChamferDistanceLoss"; }
/**
* Unlike most loss layers, in the ChamferDistanceLossLayer we can
* backpropagate to both inputs -- override to return true and always allow
* force_backward.
*/
virtual inline bool AllowForceBackward(const int bottom_index) const {
return true;
}
protected:
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<int> indexes1_;
Blob<int> indexes2_;
};
} // namespace caffe
#endif // CAFFE_CHAMFER_DISTANCE_LAYER_HPP_chamfer_distance_loss_layer.cpp
#include <iostream>
#include <vector>
#include "caffe/layers/chamfer_distance_loss_layer.hpp"
#include "caffe/util/math_functions.hpp"
namespace caffe {
template <typename Dtype>
void ChamferDistanceLossLayer<Dtype>::LayerSetUp(
const vector<Blob<Dtype>*>& bottom, const vector<Blob<Dtype>*>& top) {
LossLayer<Dtype>::LayerSetUp(bottom, top);
CHECK_EQ(bottom[0]->num(), bottom[1]->num());
CHECK_EQ(bottom[0]->height(), 3);
CHECK_EQ(bottom[1]->height(), 3);
CHECK_EQ(bottom[1]->width(), 1);
CHECK_EQ(bottom[1]->width(), 1);
}
template <typename Dtype>
void ChamferDistanceLossLayer<Dtype>::Reshape(
const vector<Blob<Dtype>*>& bottom, const vector<Blob<Dtype>*>& top) {
LossLayer<Dtype>::Reshape(bottom, top);
indexes1_.Reshape(bottom[0]->num(), bottom[0]->channels(), 1, 1);
indexes2_.Reshape(bottom[1]->num(), bottom[1]->channels(), 1, 1);
}
template <typename Dtype>
void ChamferDistanceLossLayer<Dtype>::Forward_cpu(
const vector<Blob<Dtype>*>& bottom, const vector<Blob<Dtype>*>& top) {
Blob<Dtype> dist1(bottom[0]->num(), bottom[0]->channels(), 1, 1);
Blob<Dtype> dist2(bottom[1]->num(), bottom[1]->channels(), 1, 1);
Dtype* m_dist1 = dist1.mutable_cpu_data();
Dtype* m_dist2 = dist2.mutable_cpu_data();
int* indexes1 = indexes1_.mutable_cpu_data();
int* indexes2 = indexes2_.mutable_cpu_data();
const int num = bottom[0]->num();
const int n_points1 = bottom[0]->channels();
const int n_points2 = bottom[1]->channels();
for (int i = 0; i < num; ++i) {
for (int j = 0; j < n_points1; ++j) {
Dtype _min_distance(1e12);
for (int k = 0; k < n_points2; ++k) {
Dtype x1 = bottom[0]->data_at(i, j, 0, 0);
Dtype y1 = bottom[0]->data_at(i, j, 1, 0);
Dtype z1 = bottom[0]->data_at(i, j, 2, 0);
Dtype x2 = bottom[1]->data_at(i, k, 0, 0);
Dtype y2 = bottom[1]->data_at(i, k, 1, 0);
Dtype z2 = bottom[1]->data_at(i, k, 2, 0);
Dtype dx = x1 - x2;
Dtype dy = y1 - y2;
Dtype dz = z1 - z2;
Dtype dist = dx * dx + dy * dy + dz * dz;
if (dist < _min_distance) {
_min_distance = dist;
indexes1[i * n_points1 + j] = k;
}
}
m_dist1[i * n_points1 + j] += _min_distance / n_points1;
}
for (int j = 0; j < n_points2; ++j) {
Dtype _min_distance(1e12);
for (int k = 0; k < n_points1; ++k) {
Dtype x1 = bottom[1]->data_at(i, j, 0, 0);
Dtype y1 = bottom[1]->data_at(i, j, 1, 0);
Dtype z1 = bottom[1]->data_at(i, j, 2, 0);
Dtype x2 = bottom[0]->data_at(i, k, 0, 0);
Dtype y2 = bottom[0]->data_at(i, k, 1, 0);
Dtype z2 = bottom[0]->data_at(i, k, 2, 0);
Dtype dx = x1 - x2;
Dtype dy = y1 - y2;
Dtype dz = z1 - z2;
Dtype dist = dx * dx + dy * dy + dz * dz;
if (dist < _min_distance) {
_min_distance = dist;
indexes2[i * n_points2 + j] = k;
}
}
m_dist2[i * n_points2 + j] += _min_distance / n_points2;
}
}
Dtype loss1 = caffe_cpu_asum(dist1.count(), dist1.cpu_data()) / num;
Dtype loss2 = caffe_cpu_asum(dist2.count(), dist2.cpu_data()) / num;
top[0]->mutable_cpu_data()[0] = loss1 + loss2;
}
template <typename Dtype>
void ChamferDistanceLossLayer<Dtype>::Backward_cpu(
const vector<Blob<Dtype>*>& top,
const vector<bool>& propagate_down,
const vector<Blob<Dtype>*>& bottom) {
const int num = bottom[0]->num();
const int n_points1 = bottom[0]->channels();
const int n_points2 = bottom[1]->channels();
Dtype grad_dist1 = Dtype(1.0) / n_points1 / num;
Dtype grad_dist2 = Dtype(1.0) / n_points2 / num;
Dtype* diff1 = bottom[0]->mutable_cpu_diff();
Dtype* diff2 = bottom[1]->mutable_cpu_diff();
for (int i = 0; i < num; ++i) {
for (int j = 0; j < n_points1; ++j) {
int k = indexes1_.data_at(i, j, 0, 0);
Dtype x1 = bottom[0]->data_at(i, j, 0, 0);
Dtype y1 = bottom[0]->data_at(i, j, 1, 0);
Dtype z1 = bottom[0]->data_at(i, j, 2, 0);
Dtype x2 = bottom[1]->data_at(i, k, 0, 0);
Dtype y2 = bottom[1]->data_at(i, k, 1, 0);
Dtype z2 = bottom[1]->data_at(i, k, 2, 0);
Dtype grad = grad_dist1 * 2;
diff1[(i * n_points1 + j) * 3 + 0] += grad * (x1 - x2);
diff1[(i * n_points1 + j) * 3 + 1] += grad * (y1 - y2);
diff1[(i * n_points1 + j) * 3 + 2] += grad * (z1 - z2);
diff2[(i * n_points2 + k) * 3 + 0] += grad * (x2 - x1);
diff2[(i * n_points2 + k) * 3 + 1] += grad * (y2 - y1);
diff2[(i * n_points2 + k) * 3 + 2] += grad * (z2 - z1);
}
}
for (int i = 0; i < num; ++i) {
for (int j = 0; j < n_points2; ++j) {
int k = indexes2_.data_at(i, j, 0, 0);
Dtype x1 = bottom[1]->data_at(i, j, 0, 0);
Dtype y1 = bottom[1]->data_at(i, j, 1, 0);
Dtype z1 = bottom[1]->data_at(i, j, 2, 0);
Dtype x2 = bottom[0]->data_at(i, k, 0, 0);
Dtype y2 = bottom[0]->data_at(i, k, 1, 0);
Dtype z2 = bottom[0]->data_at(i, k, 2, 0);
Dtype grad = grad_dist2 * 2;
diff2[(i * n_points2 + j) * 3 + 0] += grad * (x1 - x2);
diff2[(i * n_points2 + j) * 3 + 1] += grad * (y1 - y2);
diff2[(i * n_points2 + j) * 3 + 2] += grad * (z1 - z2);
diff1[(i * n_points1 + k) * 3 + 0] += grad * (x2 - x1);
diff1[(i * n_points1 + k) * 3 + 1] += grad * (y2 - y1);
diff1[(i * n_points1 + k) * 3 + 2] += grad * (z2 - z1);
}
}
}
#ifdef CPU_ONLY
STUB_GPU(ChamferDistanceLossLayer);
#endif
INSTANTIATE_CLASS(ChamferDistanceLossLayer);
REGISTER_LAYER_CLASS(ChamferDistanceLoss);
} // namespace caffetest_chamfer_distance_layer.cpp
#include <stdio.h>
#include <vector>
#include "gtest/gtest.h"
#include "caffe/blob.hpp"
#include "caffe/common.hpp"
#include "caffe/filler.hpp"
#include "caffe/layers/chamfer_distance_loss_layer.hpp"
#include "caffe/test/test_caffe_main.hpp"
#include "caffe/test/test_gradient_check_util.hpp"
namespace caffe {
template <typename TypeParam>
class ChamferDistanceLossLayerTest : public MultiDeviceTest<TypeParam> {
typedef typename TypeParam::Dtype Dtype;
protected:
ChamferDistanceLossLayerTest()
: blob_bottom_ptcloud_(new Blob<Dtype>(2, 10, 3, 1)),
blob_bottom_gtcloud_(new Blob<Dtype>(2, 10, 3, 1)),
blob_top_loss_(new Blob<Dtype>()) {
Caffe::set_random_seed(1701);
FillerParameter filler_param;
UniformFiller<Dtype> filler(filler_param);
// filler.Fill(this->blob_bottom_ptcloud_);
// filler.Fill(this->blob_bottom_gtcloud_);
Dtype* ptcloud_ = blob_bottom_ptcloud_->mutable_cpu_data();
Dtype* gtcloud_ = blob_bottom_gtcloud_->mutable_cpu_data();
ptcloud_[0] = 0.4011; ptcloud_[1] = 0.2908; ptcloud_[2] = 0.3521;
ptcloud_[3] = 0.0861; ptcloud_[4] = 0.8777; ptcloud_[5] = 0.4353;
ptcloud_[6] = 0.7420; ptcloud_[7] = 0.1549; ptcloud_[8] = 0.8189;
ptcloud_[9] = 0.3323; ptcloud_[10] = 0.4617; ptcloud_[11] = 0.2126;
ptcloud_[12] = 0.2867; ptcloud_[13] = 0.9608; ptcloud_[14] = 0.6667;
ptcloud_[15] = 0.1773; ptcloud_[16] = 0.5807; ptcloud_[17] = 0.0388;
ptcloud_[18] = 0.4252; ptcloud_[19] = 0.6412; ptcloud_[20] = 0.6042;
ptcloud_[21] = 0.7260; ptcloud_[22] = 0.5044; ptcloud_[23] = 0.8364;
ptcloud_[24] = 0.7606; ptcloud_[25] = 0.0383; ptcloud_[26] = 0.2995;
ptcloud_[27] = 0.3635; ptcloud_[28] = 0.5297; ptcloud_[29] = 0.2056;
ptcloud_[30] = 0.2465; ptcloud_[31] = 0.2190; ptcloud_[32] = 0.4713;
ptcloud_[33] = 0.2807; ptcloud_[34] = 0.0673; ptcloud_[35] = 0.5035;
ptcloud_[36] = 0.1563; ptcloud_[37] = 0.4924; ptcloud_[38] = 0.3246;
ptcloud_[39] = 0.0118; ptcloud_[40] = 0.4919; ptcloud_[41] = 0.7165;
ptcloud_[42] = 0.3805; ptcloud_[43] = 0.4503; ptcloud_[44] = 0.0220;
ptcloud_[45] = 0.6650; ptcloud_[46] = 0.7816; ptcloud_[47] = 0.0317;
ptcloud_[48] = 0.5174; ptcloud_[49] = 0.9315; ptcloud_[50] = 0.3767;
ptcloud_[51] = 0.6830; ptcloud_[52] = 0.9195; ptcloud_[53] = 0.3598;
ptcloud_[54] = 0.1752; ptcloud_[55] = 0.6147; ptcloud_[56] = 0.8423;
ptcloud_[57] = 0.9798; ptcloud_[58] = 0.8040; ptcloud_[59] = 0.7357;
gtcloud_[0] = 0.9321; gtcloud_[1] = 0.7667; gtcloud_[2] = 0.2552;
gtcloud_[3] = 0.7745; gtcloud_[4] = 0.1306; gtcloud_[5] = 0.2459;
gtcloud_[6] = 0.2194; gtcloud_[7] = 0.3606; gtcloud_[8] = 0.9956;
gtcloud_[9] = 0.4877; gtcloud_[10] = 0.2506; gtcloud_[11] = 0.1692;
gtcloud_[12] = 0.5293; gtcloud_[13] = 0.4913; gtcloud_[14] = 0.3616;
gtcloud_[15] = 0.6573; gtcloud_[16] = 0.5852; gtcloud_[17] = 0.2728;
gtcloud_[18] = 0.0400; gtcloud_[19] = 0.3716; gtcloud_[20] = 0.4207;
gtcloud_[21] = 0.6753; gtcloud_[22] = 0.2750; gtcloud_[23] = 0.8677;
gtcloud_[24] = 0.9813; gtcloud_[25] = 0.7300; gtcloud_[26] = 0.1378;
gtcloud_[27] = 0.7216; gtcloud_[28] = 0.7457; gtcloud_[29] = 0.4421;
gtcloud_[30] = 0.3020; gtcloud_[31] = 0.9361; gtcloud_[32] = 0.7699;
gtcloud_[33] = 0.5319; gtcloud_[34] = 0.1045; gtcloud_[35] = 0.0440;
gtcloud_[36] = 0.5918; gtcloud_[37] = 0.5900; gtcloud_[38] = 0.8566;
gtcloud_[39] = 0.5447; gtcloud_[40] = 0.0098; gtcloud_[41] = 0.4900;
gtcloud_[42] = 0.8860; gtcloud_[43] = 0.1312; gtcloud_[44] = 0.6319;
gtcloud_[45] = 0.0322; gtcloud_[46] = 0.6574; gtcloud_[47] = 0.8497;
gtcloud_[48] = 0.0314; gtcloud_[49] = 0.3995; gtcloud_[50] = 0.6097;
gtcloud_[51] = 0.1369; gtcloud_[52] = 0.4054; gtcloud_[53] = 0.4159;
gtcloud_[54] = 0.1296; gtcloud_[55] = 0.2437; gtcloud_[56] = 0.9193;
gtcloud_[57] = 0.5789; gtcloud_[58] = 0.0539; gtcloud_[59] = 0.0890;
blob_bottom_vec_.push_back(blob_bottom_ptcloud_);
blob_bottom_vec_.push_back(blob_bottom_gtcloud_);
blob_top_vec_.push_back(blob_top_loss_);
}
virtual ~ChamferDistanceLossLayerTest() {
delete blob_bottom_ptcloud_;
delete blob_bottom_gtcloud_;
delete blob_top_loss_;
}
Blob<Dtype>* const blob_bottom_ptcloud_;
Blob<Dtype>* const blob_bottom_gtcloud_;
Blob<Dtype>* const blob_top_loss_;
vector<Blob<Dtype>*> blob_bottom_vec_;
vector<Blob<Dtype>*> blob_top_vec_;
};
TYPED_TEST_CASE(ChamferDistanceLossLayerTest, TestDtypesAndDevices);
TYPED_TEST(ChamferDistanceLossLayerTest, TestForward) {
typedef typename TypeParam::Dtype Dtype;
LayerParameter layer_param;
ChamferDistanceLossLayer<Dtype> layer(layer_param);
layer.SetUp(this->blob_bottom_vec_, this->blob_top_vec_);
const Dtype cd_loss =
layer.Forward(this->blob_bottom_vec_, this->blob_top_vec_);
Dtype loss(0);
const int num = this->blob_bottom_gtcloud_->num();
const int n_points1 = this->blob_bottom_ptcloud_->channels();
const int n_points2 = this->blob_bottom_gtcloud_->channels();
for (int i = 0; i < num; ++i) {
Dtype min_distance1(0);
Dtype min_distance2(0);
for (int j = 0; j < n_points1; ++j) {
Dtype _min_distance(1e12);
for (int k = 0; k < n_points2; ++k) {
Dtype x1 = this->blob_bottom_ptcloud_->data_at(i, j, 0, 0);
Dtype y1 = this->blob_bottom_ptcloud_->data_at(i, j, 1, 0);
Dtype z1 = this->blob_bottom_ptcloud_->data_at(i, j, 2, 0);
Dtype x2 = this->blob_bottom_gtcloud_->data_at(i, k, 0, 0);
Dtype y2 = this->blob_bottom_gtcloud_->data_at(i, k, 1, 0);
Dtype z2 = this->blob_bottom_gtcloud_->data_at(i, k, 2, 0);
Dtype dx = x1 - x2;
Dtype dy = y1 - y2;
Dtype dz = z1 - z2;
Dtype dist = dx * dx + dy * dy + dz * dz;
if (dist < _min_distance) {
_min_distance = dist;
}
}
min_distance1 += _min_distance;
}
for (int j = 0; j < n_points2; ++j) {
Dtype _min_distance(1e12);
for (int k = 0; k < n_points1; ++k) {
Dtype x1 = this->blob_bottom_gtcloud_->data_at(i, j, 0, 0);
Dtype y1 = this->blob_bottom_gtcloud_->data_at(i, j, 1, 0);
Dtype z1 = this->blob_bottom_gtcloud_->data_at(i, j, 2, 0);
Dtype x2 = this->blob_bottom_ptcloud_->data_at(i, k, 0, 0);
Dtype y2 = this->blob_bottom_ptcloud_->data_at(i, k, 1, 0);
Dtype z2 = this->blob_bottom_ptcloud_->data_at(i, k, 2, 0);
Dtype dx = x1 - x2;
Dtype dy = y1 - y2;
Dtype dz = z1 - z2;
Dtype dist = dx * dx + dy * dy + dz * dz;
if (dist < _min_distance) {
_min_distance = dist;
}
}
min_distance2 += _min_distance;
}
min_distance1 /= n_points1;
min_distance2 /= n_points2;
loss += min_distance1 + min_distance2;
}
loss /= num;
std::cout << "loss = " << loss << std::endl;
EXPECT_NEAR(cd_loss, loss, 1e-5);
}
// Disabled due to the bugs in GradientChecker.
// The gradient of ChamferDistanceLoss has the same output as the PyTorch
// version.
TYPED_TEST(ChamferDistanceLossLayerTest, TestGradient) {
typedef typename TypeParam::Dtype Dtype;
LayerParameter layer_param;
ChamferDistanceLossLayer<Dtype> layer(layer_param);
layer.SetUp(this->blob_bottom_vec_, this->blob_top_vec_);
GradientChecker<Dtype> checker(1e-2, 1e-2, 1701);
checker.CheckGradientExhaustive(&layer, this->blob_bottom_vec_,
this->blob_top_vec_);
}
} // namespace caffe
Issue summary
The estimated gradients by
GradientCheckerare not correct. I implemented my own Caffe layer and the gradients are the same as PyTorch and JAX. ButGradientCheckertells me that my gradient are not correct.Steps to reproduce
make -j8make runtest GTEST_FILTER='Chamfer*' -j8Tried solutions
Compare my gradients with autograd and PyTorch. And they are the same.
System configuration
Issue checklist