TYPED_TEST(DeconvolutionLayerTest, TestGradient3D) {
typedef typename TypeParam::Dtype Dtype;
vector<int> bottom_shape(5);
bottom_shape[0] = this->blob_bottom_vec_[0]->shape(0);
bottom_shape[1] = this->blob_bottom_vec_[0]->shape(1);
bottom_shape[2] = 2;
bottom_shape[3] = 3;
bottom_shape[4] = 2;
FillerParameter filler_param;
GaussianFiller<Dtype> filler(filler_param);
for (int i = 0; i < this->blob_bottom_vec_.size(); ++i) {
this->blob_bottom_vec_[i]->Reshape(bottom_shape);
filler.Fill(this->blob_bottom_vec_[i]);
}
LayerParameter layer_param;
ConvolutionParameter* convolution_param = layer_param.mutable_convolution_param();
convolution_param->add_kernel_size(2);
convolution_param->add_stride(2);
convolution_param->add_pad(1);
convolution_param->set_num_output(2);
convolution_param->mutable_weight_filler()->set_type("gaussian");
convolution_param->mutable_bias_filler()->set_type("gaussian");
DeconvolutionLayer<Dtype, Dtype> layer(layer_param);
GradientChecker<Dtype> checker(tol<Dtype>(1e-2, 1e-1), tol<Dtype>(1e-3, 1e-1));
checker.CheckGradientExhaustive(&layer, this->blob_bottom_vec_, this->blob_top_vec_);
}
TYPED_TEST(MKLDNNConvolutionLayerTest, TestSimple3DConvolution) {
typedef typename TypeParam::Dtype Dtype;
this->blob_bottom_vec_.push_back(this->blob_bottom_2_);
this->blob_top_vec_.push_back(this->blob_top_2_);
vector<int> bottom_shape(5);
bottom_shape[0] = this->blob_bottom_vec_[0]->shape(0);
bottom_shape[1] = this->blob_bottom_vec_[0]->shape(1);
bottom_shape[2] = 5;
bottom_shape[3] = this->blob_bottom_vec_[0]->shape(2);
bottom_shape[4] = this->blob_bottom_vec_[0]->shape(3);
FillerParameter filler_param;
GaussianFiller<Dtype> filler(filler_param);
for (int i = 0; i < this->blob_bottom_vec_.size(); ++i) {
this->blob_bottom_vec_[i]->Reshape(bottom_shape);
filler.Fill(this->blob_bottom_vec_[i]);
}
LayerParameter layer_param;
ConvolutionParameter* convolution_param =
layer_param.mutable_convolution_param();
convolution_param->add_kernel_size(3);
convolution_param->add_stride(2);
convolution_param->set_num_output(4);
convolution_param->mutable_weight_filler()->set_type("gaussian");
convolution_param->mutable_bias_filler()->set_type("gaussian");
shared_ptr<Layer<Dtype> > layer(
new MKLDNNConvolutionLayer<Dtype>(layer_param));
layer->SetUp(this->blob_bottom_vec_, this->blob_top_vec_);
layer->Forward(this->blob_bottom_vec_, this->blob_top_vec_);
// Check against reference convolution.
const Dtype* top_data;
const Dtype* ref_top_data;
caffe_conv(this->blob_bottom_, convolution_param, layer->blobs(),
this->MakeReferenceTop(this->blob_top_));
top_data = this->blob_top_->cpu_data();
ref_top_data = this->ref_blob_top_->cpu_data();
for (int i = 0; i < this->blob_top_->count(); ++i) {
EXPECT_NEAR(top_data[i], ref_top_data[i], 1e-4);
}
#if 0 // TODO: improve conv so that it runs on all buffers in bottom vector
caffe_conv(this->blob_bottom_2_, convolution_param, layer->blobs(),
this->MakeReferenceTop(this->blob_top_2_));
top_data = this->blob_top_2_->cpu_data();
ref_top_data = this->ref_blob_top_->cpu_data();
for (int i = 0; i < this->blob_top_->count(); ++i) {
EXPECT_NEAR(top_data[i], ref_top_data[i], 1e-4);
}
#endif
}
TYPED_TEST(DeconvolutionLayerTest, TestNDAgainst2D) {
typedef typename TypeParam::Dtype Dtype;
const int kernel_h = 11;
const int kernel_w = 13;
vector<int> bottom_shape(4);
bottom_shape[0] = 15;
bottom_shape[1] = 12;
bottom_shape[2] = kernel_h * 2;
bottom_shape[3] = kernel_w * 2;
FillerParameter filler_param;
GaussianFiller<Dtype> filler(filler_param);
for (int i = 0; i < this->blob_bottom_vec_.size(); ++i) {
this->blob_bottom_vec_[i]->Reshape(bottom_shape);
filler.Fill(this->blob_bottom_vec_[i]);
}
LayerParameter layer_param;
ConvolutionParameter* convolution_param = layer_param.mutable_convolution_param();
convolution_param->set_num_output(18);
convolution_param->set_bias_term(false);
convolution_param->set_group(6);
convolution_param->set_kernel_h(kernel_h);
convolution_param->set_kernel_w(kernel_w);
convolution_param->mutable_weight_filler()->set_type("gaussian");
TBlob<Dtype> weights;
TBlob<Dtype> top_diff;
// Shape and fill weights and top_diff.
bool copy_diff;
bool reshape;
{
DeconvolutionLayer<Dtype, Dtype> layer(layer_param);
layer.SetUp(this->blob_bottom_vec_, this->blob_top_vec_);
top_diff.ReshapeLike(*this->blob_top_);
filler.Fill(&top_diff);
ASSERT_EQ(1, layer.blobs().size());
copy_diff = false;
reshape = true;
weights.CopyFrom(*layer.blobs()[0], copy_diff, reshape);
}
vector<bool> propagate_down(1, true);
TBlob<Dtype> result_2d;
TBlob<Dtype> backward_result_2d;
TBlob<Dtype> backward_weight_result_2d;
// Test with 2D im2col
{
caffe_set<Dtype>(this->blob_top_->count(), TypedConsts<Dtype>::zero,
this->blob_top_->mutable_cpu_data());
caffe_set<Dtype>(this->blob_bottom_->count(), TypedConsts<Dtype>::zero,
this->blob_bottom_->mutable_cpu_diff());
caffe_set<Dtype>(weights.count(), TypedConsts<Dtype>::zero, weights.mutable_cpu_diff());
// Do SetUp and Forward; save Forward result in result_2d.
convolution_param->set_force_nd_im2col(false);
DeconvolutionLayer<Dtype, Dtype> layer_2d(layer_param);
layer_2d.SetUp(this->blob_bottom_vec_, this->blob_top_vec_);
ASSERT_EQ(1, layer_2d.blobs().size());
copy_diff = false;
reshape = false;
layer_2d.blobs()[0]->CopyFrom(weights, copy_diff, reshape);
layer_2d.Forward(this->blob_bottom_vec_, this->blob_top_vec_);
copy_diff = false;
reshape = true;
result_2d.CopyFrom(*this->blob_top_, copy_diff, reshape);
// Copy pre-generated top diff into actual top diff;
// do Backward and save result in backward_result_2d.
ASSERT_EQ(this->blob_top_->shape(), top_diff.shape());
caffe_copy<Dtype>(top_diff.count(), top_diff.cpu_data(), this->blob_top_->mutable_cpu_diff());
layer_2d.Backward(this->blob_top_vec_, propagate_down, this->blob_bottom_vec_);
copy_diff = true;
reshape = true;
backward_result_2d.CopyFrom(*this->blob_bottom_, copy_diff, reshape);
backward_weight_result_2d.CopyFrom(weights, copy_diff, reshape);
}
TBlob<Dtype> result_nd;
TBlob<Dtype> backward_result_nd;
TBlob<Dtype> backward_weight_result_nd;
// Test with ND im2col
{
caffe_set<Dtype>(this->blob_top_->count(), TypedConsts<Dtype>::zero,
this->blob_top_->mutable_cpu_data());
caffe_set<Dtype>(this->blob_bottom_->count(), TypedConsts<Dtype>::zero,
this->blob_bottom_->mutable_cpu_diff());
caffe_set<Dtype>(weights.count(), TypedConsts<Dtype>::zero, weights.mutable_cpu_diff());
// Do SetUp and Forward; save Forward result in result_nd.
convolution_param->set_force_nd_im2col(true);
DeconvolutionLayer<Dtype, Dtype> layer_nd(layer_param);
layer_nd.SetUp(this->blob_bottom_vec_, this->blob_top_vec_);
ASSERT_EQ(1, layer_nd.blobs().size());
copy_diff = false;
reshape = false;
layer_nd.blobs()[0]->CopyFrom(weights, copy_diff, reshape);
layer_nd.Forward(this->blob_bottom_vec_, this->blob_top_vec_);
copy_diff = false;
reshape = true;
result_nd.CopyFrom(*this->blob_top_, copy_diff, reshape);
// Copy pre-generated top diff into actual top diff;
// do Backward and save result in backward_result_nd.
ASSERT_EQ(this->blob_top_->shape(), top_diff.shape());
caffe_copy<Dtype>(top_diff.count(), top_diff.cpu_data(), this->blob_top_->mutable_cpu_diff());
layer_nd.Backward(this->blob_top_vec_, propagate_down, this->blob_bottom_vec_);
copy_diff = true;
reshape = true;
backward_result_nd.CopyFrom(*this->blob_bottom_, copy_diff, reshape);
backward_weight_result_nd.CopyFrom(weights, copy_diff, reshape);
}
ASSERT_EQ(result_nd.count(), result_2d.count());
for (int i = 0; i < result_2d.count(); ++i) {
if (is_type<Dtype>(FLOAT16))
EXPECT_NEAR(result_2d.cpu_data()[i], result_nd.cpu_data()[i], 0.5F);
else
EXPECT_EQ(result_2d.cpu_data()[i], result_nd.cpu_data()[i]);
}
ASSERT_EQ(backward_result_nd.count(), backward_result_2d.count());
for (int i = 0; i < backward_result_2d.count(); ++i) {
EXPECT_EQ(backward_result_2d.cpu_diff()[i], backward_result_nd.cpu_diff()[i]);
}
ASSERT_EQ(backward_weight_result_nd.count(), backward_weight_result_2d.count());
for (int i = 0; i < backward_weight_result_2d.count(); ++i) {
EXPECT_EQ(backward_weight_result_2d.cpu_diff()[i], backward_weight_result_nd.cpu_diff()[i]);
}
}
