void TestForward(){ // Get the loss without a specific object weight LayerParameter layer_param; // set some hyper parameter TripletCrossEntropyLossParameter* triplet_cross_param = layer_param.mutable_triplet_cross_entropy_loss_param(); triplet_cross_param->set_dim(12); TripletCrossEntropyLossLayer<Dtype> layer_weight_1(layer_param); layer_weight_1.SetUp(this->blob_bottom_vec_, this->blob_top_vec_); const Dtype loss_weight_1 = layer_weight_1.Forward(this->blob_bottom_vec_, this->blob_top_vec_); //Get the loss again with a different object weight; //check that it is scaled appropriately const Dtype kLossWeight = 7.7; layer_param.add_loss_weight(kLossWeight); TripletCrossEntropyLossLayer<Dtype> layer_weight_2(layer_param); layer_weight_2.SetUp(this->blob_bottom_vec_, this->blob_top_vec_); const Dtype loss_weight_2 = layer_weight_2.Forward(this->blob_bottom_vec_, this->blob_top_vec_); const Dtype kErrorMargin = 1e-5; EXPECT_NEAR(loss_weight_1*kLossWeight, loss_weight_2, kErrorMargin); //Make sure the loss is non-trivial const Dtype kNonTrivialAbsThresh = 1e-1; EXPECT_GE(fabs(loss_weight_1), kNonTrivialAbsThresh); }
void TestForward() { // Get the loss without a specified objective weight -- should be // equivalent to explicitly specifiying a weight of 1. LayerParameter layer_param; TripletLossLayer<Dtype> layer_weight_1(layer_param); layer_weight_1.SetUp(this->blob_bottom_vec_, this->blob_top_vec_); //const Dtype loss_weight_1 = layer_weight_1.Forward(this->blob_bottom_vec_, this->blob_top_vec_); /* // Get the loss again with a different objective weight; check that it is // scaled appropriately. const Dtype kLossWeight = 3.7; layer_param.add_loss_weight(kLossWeight); TripletLossLayer<Dtype> layer_weight_2(layer_param); layer_weight_2.SetUp(this->blob_bottom_vec_, this->blob_top_vec_); const Dtype loss_weight_2 = layer_weight_2.Forward(this->blob_bottom_vec_, this->blob_top_vec_); const Dtype kErrorMargin = 1e-5; EXPECT_NEAR(loss_weight_1 * kLossWeight, loss_weight_2, kErrorMargin); // Make sure the loss is non-trivial. const Dtype kNonTrivialAbsThresh = 1e-1; EXPECT_GE(fabs(loss_weight_1), kNonTrivialAbsThresh); */ }
void TestForward() { // Get the loss without a specified objective weight -- should be // equivalent to explicitly specifiying a weight of 1. LayerParameter layer_param; layer_param.mutable_multi_t_loss_param()->set_num_center(N_); EntropyTLossLayer<Dtype> layer_weight_1(layer_param); layer_weight_1.SetUp(this->blob_bottom_vec_, &this->blob_top_vec_); layer_weight_1.Forward(this->blob_bottom_vec_, &this->blob_top_vec_); FillerParameter filler_param; GaussianFiller<Dtype> filler2(filler_param); filler2.Fill(layer_weight_1.blobs()[0].get()); caffe_rng_uniform(layer_weight_1.blobs()[1]->count(), Dtype(0.9), Dtype(1.1), layer_weight_1.blobs()[1]->mutable_cpu_data()); layer_weight_1.SetUp(this->blob_bottom_vec_, &this->blob_top_vec_); const Dtype loss_weight_1 = layer_weight_1.Forward(this->blob_bottom_vec_, &this->blob_top_vec_); // Get the loss again with a different objective weight; check that it is // scaled appropriately. const Dtype kLossWeight = 3.7; LayerParameter layer_param2; layer_param2.mutable_multi_t_loss_param()->set_num_center(N_); layer_param2.add_loss_weight(kLossWeight); EntropyTLossLayer<Dtype> layer_weight_2(layer_param2); layer_weight_2.SetUp(this->blob_bottom_vec_, &this->blob_top_vec_); layer_weight_2.Forward(this->blob_bottom_vec_, &this->blob_top_vec_); caffe_copy(layer_weight_2.blobs()[0]->count(), layer_weight_1.blobs()[0]->cpu_data(), layer_weight_2.blobs()[0]->mutable_cpu_data()); caffe_copy(layer_weight_2.blobs()[1]->count(), layer_weight_1.blobs()[1]->cpu_data(), layer_weight_2.blobs()[1]->mutable_cpu_data()); layer_weight_2.SetUp(this->blob_bottom_vec_, &this->blob_top_vec_); const Dtype loss_weight_2 = layer_weight_2.Forward(this->blob_bottom_vec_, &this->blob_top_vec_); const Dtype kErrorMargin = 1e-3; EXPECT_NEAR(loss_weight_1 * kLossWeight, loss_weight_2, kErrorMargin); // Make sure the loss is non-trivial. const Dtype kNonTrivialAbsThresh = 1e-1; EXPECT_GE(fabs(loss_weight_1), kNonTrivialAbsThresh); int m = M_, n = layer_param.multi_t_loss_param().num_center(), p = K_; Blob<Dtype> *distance = layer_weight_1.distance(); const Dtype *cpu_data = blob_bottom_data_->cpu_data(); const Dtype *cpu_dist = distance->cpu_data(); const Dtype *cpu_center = layer_weight_1.blobs()[0]->cpu_data(); const Dtype *cpu_sigma = layer_weight_1.blobs()[1]->cpu_data(); for (int i = 0; i < m; ++i) { for (int j = 0; j < n; ++j) { Dtype acc = Dtype(0); for (int k = 0; k < p; ++k) { acc += (cpu_data[i*p + k] - cpu_center[k*n + j])*(cpu_data[i*p + k] - cpu_center[k*n + j])*cpu_sigma[k*n+j]; } EXPECT_NEAR(acc, cpu_dist[i*n + j], kErrorMargin) << i << " " << j; } } }