C++ caffe_cpu_axpby函数代码示例

void cal_add_item_cpu<float>(const float co, const int N, const int K, const float* W, const float* x1, float* tempX1,
                             const float* x2, float* tempX2, const float gamma, float* KK) {

    memset(tempX1, 0, sizeof(float) * K);
    memset(tempX2, 0, sizeof(float) * K);

    caffe_cpu_gemv<float>(CblasNoTrans, N, K, 1.0, W, x1, 0.0, tempX1);
    caffe_cpu_gemv<float>(CblasNoTrans, N, K, 1.0, W, x2, 0.0, tempX2);

    float square_sum = 0;

    caffe_cpu_axpby(K, -1.0f, tempX2, 1.0f, tempX1);
    caffe_cpu_axpby(K, 1.0f, x1, 0.0f, tempX2);
    caffe_cpu_axpby(K, -1.0f, x2, 1.0f, tempX2);
    square_sum = caffe_cpu_dot<float>(K, tempX1, tempX1);

    //calculate 2 * \gamma * kernel
    float kernel = 0.0f;
    float tempGamma = gamma / 4.0f;
    for(int i = 0; i < 5; ++i) {
        float temp = (0.0 - tempGamma) * square_sum;
        temp = exp(temp);
        kernel += 2 * tempGamma* temp;
        tempGamma = tempGamma * 2;
    }
    /*float kernel = (0.0 - gamma) * square_sum;
    kernel = exp(kernel);
    kernel = 2 * gamma * kernel;
    */
    //calculate KK <- co * kernel * X^T * W + 1 * KK
    caffe_cpu_gemm<float>(CblasNoTrans, CblasTrans, 1, N, K, co*kernel, tempX2, W, 0.0, KK);
}

void TripletClsLossLayer<Dtype>::Backward_cpu(const vector<Blob<Dtype>*>& top,
      const vector<bool>& propagate_down, const vector<Blob<Dtype>*>& bottom){
         
  int num = bottom[0]->num();  
  int channels = bottom[0]->channels();

  for (int n = 0; n < num; ++n) {
    if (propagate_down[0]) {                                           
	    if(const_.cpu_data()[n] > Dtype(0.0)){
		
               //derivative in relation to image                
                 caffe_cpu_axpby(channels, Dtype( 2./num), diff_impostor_target.cpu_data() + bottom[0]->offset(n), Dtype(0.0),
                                bottom[0]->mutable_cpu_diff() + bottom[0]->offset(n));

		//derivative in relation to target                
                caffe_cpu_axpby(channels, Dtype( 2./num), diff_sample_target.cpu_data() + bottom[1]->offset(n), Dtype(0.0),
                                bottom[1]->mutable_cpu_diff() + bottom[1]->offset(n));                 

		//derivative in relation to impostor
                caffe_cpu_axpby(channels, Dtype( -2./num), diff_sample_impostor.cpu_data() + bottom[2]->offset(n), Dtype(0.0),
                                bottom[2]->mutable_cpu_diff() + bottom[2]->offset(n));     

		           
            }else{

		caffe_set(channels, Dtype(0.0), bottom[0]->mutable_cpu_diff() + bottom[0]->offset(n));
                caffe_set(channels, Dtype(0.0), bottom[1]->mutable_cpu_diff() + bottom[1]->offset(n));
                caffe_set(channels, Dtype(0.0), bottom[2]->mutable_cpu_diff() + bottom[2]->offset(n));

	    }
    }           
 }
}

void ContrastiveLossLayer<Dtype>::Backward_cpu(const vector<Blob<Dtype>*>& top,
    const vector<bool>& propagate_down, const vector<Blob<Dtype>*>& bottom) {
  Dtype margin = this->layer_param_.contrastive_loss_param().margin();
  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] /
          static_cast<Dtype>(bottom[i]->num());
      int num = bottom[i]->num();
      int channels = bottom[i]->channels();
      for (int j = 0; j < num; ++j) {
        Dtype* bout = bottom[i]->mutable_cpu_diff();
        if (static_cast<int>(bottom[2]->cpu_data()[j])) {  // similar pairs
          caffe_cpu_axpby(
              channels,
              alpha,
              diff_.cpu_data() + (j*channels),
              Dtype(0.0),
              bout + (j*channels));
        } else {  // dissimilar pairs
          if ((margin-dist_sq_.cpu_data()[j]) > Dtype(0.0)) {
            caffe_cpu_axpby(
                channels,
                -alpha,
                diff_.cpu_data() + (j*channels),
                Dtype(0.0),
                bout + (j*channels));
          } else {
            caffe_set(channels, Dtype(0), bout + (j*channels));
          }
        }
      }
    }
  }
}

void NesterovSolver<Dtype>::ComputeUpdateValue(int param_id, Dtype rate) {
  CHECK(Caffe::root_solver());
  const vector<Blob<Dtype>*>& net_params = this->net_->learnable_params();
  const vector<float>& net_params_lr = this->net_->params_lr();
  Dtype momentum = this->param_.momentum();
  Dtype local_rate = rate * net_params_lr[param_id];
  switch (Caffe::mode()) {
  case Caffe::CPU: {
    // save history momentum for stepping back
    caffe_copy(net_params[param_id]->count(),
        this->history_[param_id]->cpu_data(),
        this->update_[param_id]->mutable_cpu_data());

    // update history
    caffe_cpu_axpby(net_params[param_id]->count(), local_rate,
              net_params[param_id]->cpu_diff(), momentum,
              this->history_[param_id]->mutable_cpu_data());

    // compute update: step back then over step
    caffe_cpu_axpby(net_params[param_id]->count(), Dtype(1) + momentum,
        this->history_[param_id]->cpu_data(), -momentum,
        this->update_[param_id]->mutable_cpu_data());

    // copy
    caffe_copy(net_params[param_id]->count(),
        this->update_[param_id]->cpu_data(),
        net_params[param_id]->mutable_cpu_diff());
    break;
  }
  case Caffe::GPU: {
#ifndef CPU_ONLY
    // save history momentum for stepping back
    caffe_copy(net_params[param_id]->count(),
        this->history_[param_id]->gpu_data(),
        this->update_[param_id]->mutable_gpu_data());

    // update history
    caffe_gpu_axpby(net_params[param_id]->count(), local_rate,
              net_params[param_id]->gpu_diff(), momentum,
              this->history_[param_id]->mutable_gpu_data());

    // compute update: step back then over step
    caffe_gpu_axpby(net_params[param_id]->count(), Dtype(1) + momentum,
        this->history_[param_id]->gpu_data(), -momentum,
        this->update_[param_id]->mutable_gpu_data());

    // copy
    caffe_copy(net_params[param_id]->count(),
        this->update_[param_id]->gpu_data(),
        net_params[param_id]->mutable_gpu_diff());
#else
    NO_GPU;
#endif
    break;
  }
  default:
    LOG(FATAL) << "Unknown caffe mode: " << Caffe::mode();
  }
}

void BinomialDevianceLossLayer<Dtype>::Forward_cpu(
    const vector<Blob<Dtype>*>& bottom,
    const vector<Blob<Dtype>*>& top) {
  n1 = 0;
  n2 = 0; 
  for (int i = 0; i < bottom[1]->num(); ++i){
    if (static_cast<int>(bottom[1]->cpu_data()[i]) == 1){
      n1++;
    }	
    else if (static_cast<int>(bottom[1]->cpu_data()[i]) == -1)	{
      n2++;
    }

  }


 // LOG(INFO) << n1 << "  " << n2;
  Dtype c = this->layer_param_.binomial_deviance_loss_param().c(); 
  for (int i = 0; i < bottom[1]->num(); ++i){
    M_.mutable_cpu_data()[i] = static_cast<int>(bottom[1]->cpu_data()[i]);
  
    if (static_cast<int>(bottom[1]->cpu_data()[i]) == 1)
      W_.mutable_cpu_data()[i] = 1.0/n1;
    else if (static_cast<int>(bottom[1]->cpu_data()[i]) == -1)	{
      W_.mutable_cpu_data()[i] = 1.0/n2;
      M_.mutable_cpu_data()[i] = -c;
    }
    else W_.mutable_cpu_data()[i] = 0.0;
  } 
  summer_vec_.Reshape(bottom[0]->num(), 1, 1, 1);
  for (int i = 0; i < bottom[0]->num(); ++i){
    exp_.mutable_cpu_data()[i] = Dtype(1);
    summer_vec_.mutable_cpu_data()[i] = Dtype(1);
  }

  Dtype alpha = this->layer_param_.binomial_deviance_loss_param().alpha(); 
  Dtype beta = this->layer_param_.binomial_deviance_loss_param().beta(); 

  caffe_cpu_axpby(
              bottom[1]->num(),
              Dtype(-alpha),
              bottom[0]->cpu_data(),
              Dtype(alpha * beta),
              exp_.mutable_cpu_data());

  caffe_mul(bottom[1]->num(), M_.cpu_data(), exp_.cpu_data(), exp_.mutable_cpu_data());
  caffe_exp(bottom[1]->num(), exp_.cpu_data(), exp_.mutable_cpu_data());
 
  caffe_cpu_axpby(bottom[1]->num(), Dtype(1), exp_.cpu_data(), Dtype(1), summer_vec_.mutable_cpu_data());
  for (int i = 0; i < bottom[0]->num(); ++i){
    summer_vec_.mutable_cpu_data()[i] = log(summer_vec_.cpu_data()[i]);
  }
//// multiply by elimination array
  caffe_mul(bottom[2]->num(), bottom[2]->cpu_data(), summer_vec_.cpu_data(), summer_vec_.mutable_cpu_data());
////
  Dtype loss = caffe_cpu_dot(bottom[1]->num(), W_.cpu_data(), summer_vec_.cpu_data());
  top[0]->mutable_cpu_data()[0] = loss;
}

void TripletLossLayer<Dtype>::Forward_cpu(const vector<Blob<Dtype>*>& bottom,
  const vector<Blob<Dtype>*>& top) {
  Dtype eps = this->layer_param_.triplet_loss_param().eps();
  Dtype loss = 0;
  Dtype margin = this->layer_param_.triplet_loss_param().margin();
  caffe_cpu_gemm(CblasNoTrans, CblasTrans, sample_num_, sample_num_,
      feature_dim_, Dtype(1), bottom[0]->cpu_data(),
      bottom[0]->cpu_data(), Dtype(0),
      inner_matrix_.mutable_cpu_data());

  for (int i = 0; i < triplet_num_; ++i) {
    int a_idx = bottom[1]->cpu_data()[i * 3];
    int p_idx = bottom[1]->cpu_data()[i * 3 + 1];
    int n_idx = bottom[1]->cpu_data()[i * 3 + 2];
    const Dtype *a_pointer = bottom[0]->cpu_data() + a_idx * feature_dim_;
    const Dtype *p_pointer = bottom[0]->cpu_data() + p_idx * feature_dim_;
    const Dtype *n_pointer = bottom[0]->cpu_data() + n_idx * feature_dim_;
    const Dtype *inner_matrix_data = inner_matrix_.cpu_data();
    Dtype a_norm = sqrt(inner_matrix_data[a_idx * sample_num_ + a_idx] + eps);
    Dtype p_norm = sqrt(inner_matrix_data[p_idx * sample_num_ + p_idx] + eps);
    Dtype n_norm = sqrt(inner_matrix_data[n_idx * sample_num_ + n_idx] + eps);
    Dtype inner_ap = inner_matrix_data[a_idx * sample_num_ + p_idx];
    Dtype inner_an = inner_matrix_data[a_idx * sample_num_ + n_idx];
    Dtype dist_ap = inner_ap / (a_norm * p_norm);
    Dtype dist_an = inner_an / (a_norm * n_norm);
    if (dist_ap - dist_an - margin < 0) {
      ComputeDiff_cpu(a_pointer, p_pointer, a_norm,
          p_norm, inner_ap, diff_ap_.mutable_cpu_data());
      ComputeDiff_cpu(a_pointer, n_pointer, a_norm,
          n_norm, inner_an, diff_an_.mutable_cpu_data());
      ComputeDiff_cpu(p_pointer, a_pointer, p_norm,
          a_norm, inner_ap, diff_pa_.mutable_cpu_data());
      ComputeDiff_cpu(n_pointer, a_pointer, n_norm,
          a_norm, inner_an, diff_na_.mutable_cpu_data());

      caffe_cpu_axpby(feature_dim_, Dtype(1),
          diff_an_.cpu_data(), Dtype(1),
          bottom_diff_.mutable_cpu_data() + (a_idx * feature_dim_));
      caffe_cpu_axpby(feature_dim_, Dtype(-1),
          diff_ap_.cpu_data(), Dtype(1),
          bottom_diff_.mutable_cpu_data() + (a_idx * feature_dim_));
      caffe_cpu_axpby(feature_dim_, Dtype(-1),
          diff_pa_.cpu_data(), Dtype(1),
          bottom_diff_.mutable_cpu_data() + (p_idx * feature_dim_));
      caffe_cpu_axpby(feature_dim_, Dtype(1),
          diff_na_.cpu_data(), Dtype(1),
          bottom_diff_.mutable_cpu_data() + (n_idx * feature_dim_));

      loss += dist_an + margin - dist_ap;
    }
  }
  //Dtype scalar = Dtype(1) / triplet_num_;
  Dtype scalar = Dtype(1) / sample_num_;
  top[0]->mutable_cpu_data()[0] = loss * scalar;
}

void RMSPropSolver<Dtype>::ComputeUpdateValue(int param_id, Dtype rate) {
  const vector<Blob<Dtype>*>& net_params = this->net_->learnable_params();
  const vector<float>& net_params_lr = this->net_->params_lr();

  // get the learning rate
  Dtype delta = this->param_.delta();
  Dtype rms_decay = this->param_.rms_decay();
  Dtype local_rate = rate * net_params_lr[param_id];

  switch (Caffe::mode()) {
  case Caffe::CPU:
    // compute square of gradient in update
    caffe_powx(net_params[param_id]->count(),
        net_params[param_id]->cpu_diff(), Dtype(2),
        this->update_[param_id]->mutable_cpu_data());

    // update history
    caffe_cpu_axpby(net_params[param_id] -> count(),
        Dtype(1-rms_decay), this->update_[param_id]->cpu_data(),
        rms_decay, this->history_[param_id]-> mutable_cpu_data());

    // prepare update
    caffe_powx(net_params[param_id]->count(),
        this->history_[param_id]->cpu_data(), Dtype(0.5),
        this->update_[param_id]->mutable_cpu_data());

    caffe_add_scalar(net_params[param_id]->count(),
        delta, this->update_[param_id]->mutable_cpu_data());

    caffe_div(net_params[param_id]->count(),
        net_params[param_id]->cpu_diff(), this->update_[param_id]->cpu_data(),
        this->update_[param_id]->mutable_cpu_data());

    // scale and copy
    caffe_cpu_axpby(net_params[param_id]->count(), local_rate,
        this->update_[param_id]->cpu_data(), Dtype(0),
        net_params[param_id]->mutable_cpu_diff());
    break;
  case Caffe::GPU:
#ifndef CPU_ONLY
    rmsprop_update_gpu(net_params[param_id]->count(),
        net_params[param_id]->mutable_gpu_diff(),
        this->history_[param_id]->mutable_gpu_data(),
        rms_decay, delta, local_rate);
#else
    NO_GPU;
#endif
    break;
  default:
    LOG(FATAL) << "Unknown caffe mode: " << Caffe::mode();
  }
}

void TripletLossLayer<Dtype>::Backward_cpu(const vector<Blob<Dtype>*>& top,  
    const vector<bool>& propagate_down, const vector<Blob<Dtype>*>& bottom) {  
  //Dtype margin = this->layer_param_.contrastive_loss_param().margin();  
  const Dtype* sampleW = bottom[3]->cpu_data();  
  for (int i = 0; i < 3; ++i) {  
    if (propagate_down[i]) {  
      const Dtype sign = (i < 2) ? -1 : 1;  
      const Dtype alpha = sign * top[0]->cpu_diff()[0] /  
          static_cast<Dtype>(bottom[i]->num());  
      int num = bottom[i]->num();  
      int channels = bottom[i]->channels();  
      for (int j = 0; j < num; ++j) {  
        Dtype* bout = bottom[i]->mutable_cpu_diff();  
        if (i==0) {  // a  
          //if(dist_binary_.cpu_data()[j]>Dtype(0)){  
              caffe_cpu_axpby(  
                  channels,  
                  alpha*sampleW[j],  
                  diff_pn_.cpu_data() + (j*channels),  
                  Dtype(0.0),  
                  bout + (j*channels));  
          //}else{  
          //  caffe_set(channels, Dtype(0), bout + (j*channels));  
          //}  
        } else if (i==1) {  // p  
          //if(dist_binary_.cpu_data()[j]>Dtype(0)){  
              caffe_cpu_axpby(  
                  channels,  
                  alpha*sampleW[j],  
                  diff_ap_.cpu_data() + (j*channels),  
                  Dtype(0.0),  
                  bout + (j*channels));  
          //}else{  
          //      caffe_set(channels, Dtype(0), bout + (j*channels));  
          //}  
        } else if (i==2) {  // n  
          //if(dist_binary_.cpu_data()[j]>Dtype(0)){  
              caffe_cpu_axpby(  
                  channels,  
                  alpha*sampleW[j],  
                  diff_an_.cpu_data() + (j*channels),  
                  Dtype(0.0),  
                  bout + (j*channels));  
           //}else{  
           //   caffe_set(channels, Dtype(0), bout + (j*channels));  
           //}  
        }  
      } // for num  
    } //if propagate_down[i]  
  } //for i  
} 

void CosineSimilarityLayer<Dtype>::Backward_cpu(const vector<Blob<Dtype>*>& top,
    const vector<bool>& propagate_down, const vector<Blob<Dtype>*>& bottom) {
  for (int i = 0; i < 2; ++i) {
    if (propagate_down[i]) {
      int num = bottom[i]->num();
      int channels = bottom[i]->channels();
      for (int j = 0; j < num; ++j) {
            Dtype denominator = pow(xx_.cpu_data()[j]*yy_.cpu_data()[j], 0.5);  
            Dtype* bout = bottom[i]->mutable_cpu_diff();
            if (i == 0){
	      caffe_cpu_axpby(
	        channels,
                Dtype(-xy_.cpu_data()[j] /(denominator* xx_.cpu_data()[j])),
                bottom[0]->cpu_data() + (j*channels),
                Dtype(0.0),
                bout + (j*channels));

              caffe_cpu_axpby(
              channels,
              Dtype(1.0/denominator),
              bottom[1]->cpu_data() + (j*channels),
              Dtype(1.0),
              bout + (j*channels));
            } else if (i == 1){
	      caffe_cpu_axpby(
	        channels,
                Dtype(-xy_.cpu_data()[j] /(denominator*yy_.cpu_data()[j])),
	        bottom[1]->cpu_data() + (j*channels),
  	        Dtype(0.0),
	        bout + (j*channels));
              caffe_cpu_axpby(
	        channels,
	        Dtype(1.0/denominator),
	        bottom[0]->cpu_data() + (j*channels),
	        Dtype(1.0),
	        bout + (j*channels));	
            }
    
            caffe_cpu_axpby(
              channels,
              Dtype(0.0),
              bout + (j*channels),
              top[0]->cpu_diff()[j],
              bout + (j*channels)
            );
      }
    }
  }

}

float cal_gamma_cpu<float>(const int K, const int S, const int N, const float* W, const float* X, float* tempX1, float* tempX2) {
    srand((unsigned int)time(0));
    float gamma = 0;
    float temp = 0;

    //random sample S pair to calculate gamma
    for(int i = 0; i < S; ++i) {
        memset(tempX1, 0, sizeof(float) * K);
        memset(tempX2, 0, sizeof(float) * K);
        int s1 = rand() % S;
        int s2 = rand() % S;
        s2 = (s1 != s2) ? s2 : (s2 + 1) % S;

        const float* x1 = X + s1 * K;
        const float* x2 = X + s2 * K;

        caffe_cpu_gemv<float>(CblasNoTrans, N, K, 1.0, W, x1, 0.0, tempX1);
        caffe_cpu_gemv<float>(CblasNoTrans, N, K, 1.0, W, x2, 0.0, tempX2);

        //caffe_cpu_sub<float>(K, tempX1, tempX2, tempX2);
        caffe_cpu_axpby(K, 1.0f, tempX1, -1.0f, tempX2);
        temp = caffe_cpu_dot<float>(K, tempX2, tempX2);
        gamma += temp;
    }
    return S / gamma;
}

void SGDSolver<Dtype>::ComputeUpdateValue(int param_id, Dtype rate) {
  const vector<Blob<Dtype>*>& net_params = this->net_->learnable_params();
  const vector<float>& net_params_lr = this->net_->params_lr();
  Dtype momentum = this->param_.momentum();
  Dtype local_rate = rate * net_params_lr[param_id];
  // Compute the update to history, then copy it to the parameter diff.
  switch (Caffe::mode()) {
  case Caffe::CPU: {
    caffe_cpu_axpby(net_params[param_id]->count(), local_rate,
              net_params[param_id]->cpu_diff(), momentum,
              history_[param_id]->mutable_cpu_data());
    caffe_copy(net_params[param_id]->count(),
        history_[param_id]->cpu_data(),
        net_params[param_id]->mutable_cpu_diff());
    break;
  }
  case Caffe::GPU: {
#ifndef CPU_ONLY
    sgd_update_gpu(net_params[param_id]->count(),
        net_params[param_id]->mutable_gpu_diff(),
        history_[param_id]->mutable_gpu_data(),
        momentum, local_rate);
#else
    NO_GPU;
#endif
    break;
  }
  default:
    LOG(FATAL) << "Unknown caffe mode: " << Caffe::mode();
  }
}

void ContrastiveLossLayer<Dtype>::Backward_cpu(const vector<Blob<Dtype>*>& top,
    const vector<bool>& propagate_down, const vector<Blob<Dtype>*>& bottom) {
  Dtype margin = this->layer_param_.contrastive_loss_param().margin();
  bool legacy_version =
      this->layer_param_.contrastive_loss_param().legacy_version();
  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] /
          static_cast<Dtype>(bottom[i]->num());
      int num = bottom[i]->num();
      int channels = bottom[i]->channels();
      for (int j = 0; j < num; ++j) {
        Dtype* bout = bottom[i]->mutable_cpu_diff();
        if (static_cast<int>(bottom[2]->cpu_data()[j]) == static_cast<int>(bottom[3]->cpu_data()[j])) {  // similar pairs
          caffe_cpu_axpby(
              channels,
              alpha,
              diff_.cpu_data() + (j*channels),
              Dtype(0.0),
              bout + (j*channels));
        } else {  // dissimilar pairs
          Dtype mdist(0.0);
          Dtype beta(0.0);
          if (legacy_version) {
            mdist = margin - dist_sq_.cpu_data()[j];
            beta = -alpha;
          } else {
            Dtype dist = sqrt(dist_sq_.cpu_data()[j]);
            mdist = margin - dist;
            beta = -alpha * mdist / (dist + Dtype(1e-4));
          }
          if (mdist > Dtype(0.0)) {
            caffe_cpu_axpby(
                channels,
                beta,
                diff_.cpu_data() + (j*channels),
                Dtype(0.0),
                bout + (j*channels));
          } else {
            caffe_set(channels, Dtype(0), bout + (j*channels));
          }
        }
      }
    }
  }
}

void EuclideanLossLayer<Dtype>::Backward_cpu(const vector<Blob<Dtype>*>& top,
    const bool propagate_down, vector<Blob<Dtype>*>* bottom) {
  int count = (*bottom)[0]->count();
  int num = (*bottom)[0]->num();
  // Compute the gradient
  caffe_cpu_axpby(count, Dtype(1) / num, difference_.cpu_data(), Dtype(0),
      (*bottom)[0]->mutable_cpu_diff());
}

void SGDFeedbackSolver<Dtype>::ComputeUpdateValue() {
  vector<shared_ptr<Blob<Dtype> > >& net_params = this->net_->params();
  vector<float>& net_params_lr = this->net_->params_lr();
  vector<float>& net_params_weight_decay = this->net_->params_weight_decay();
  // get the learning rate
  Dtype rate = GetLearningRate();
  if (this->param_.display() && this->iter_ % this->param_.display() == 0) {
    LOG(INFO) << "Iteration " << this->iter_ << ", lr = " << rate;
  }
  Dtype momentum = this->param_.momentum();
  Dtype weight_decay = this->param_.weight_decay();
  switch (Caffe::mode()) {
  case Caffe::CPU:
    for (int param_id = 0; param_id < net_params.size(); ++param_id) {
      // Compute the value to history, and then copy them to the blob's diff.
      Dtype local_rate = rate * net_params_lr[param_id];
      Dtype local_decay = weight_decay * net_params_weight_decay[param_id];
      caffe_cpu_axpby(net_params[param_id]->count(), local_rate,
          net_params[param_id]->cpu_diff(), momentum,
          history_[param_id]->mutable_cpu_data());
      if (local_decay) {
        // add weight decay
        caffe_axpy(net_params[param_id]->count(),
            local_decay * local_rate,
            net_params[param_id]->cpu_data(),
            history_[param_id]->mutable_cpu_data());
      }
      // copy
      caffe_copy(net_params[param_id]->count(),
          history_[param_id]->cpu_data(),
          net_params[param_id]->mutable_cpu_diff());
    }
    break;
  case Caffe::GPU:
    for (int param_id = 0; param_id < net_params.size(); ++param_id) {
      // Compute the value to history, and then copy them to the blob's diff.
      Dtype local_rate = rate * net_params_lr[param_id];
      Dtype local_decay = weight_decay * net_params_weight_decay[param_id];
      caffe_gpu_axpby(net_params[param_id]->count(), local_rate,
          net_params[param_id]->gpu_diff(), momentum,
          history_[param_id]->mutable_gpu_data());
      if (local_decay) {
        // add weight decay
        caffe_gpu_axpy(net_params[param_id]->count(),
            local_decay * local_rate,
            net_params[param_id]->gpu_data(),
            history_[param_id]->mutable_gpu_data());
      }
      // copy
      caffe_gpu_copy(net_params[param_id]->count(),
          history_[param_id]->gpu_data(),
          net_params[param_id]->mutable_gpu_diff());
    }
    break;
  default:
    LOG(FATAL) << "Unknown caffe mode: " << Caffe::mode();
  }
}

void VoxelCustomLossLayer<Dtype>::Backward_cpu(const vector<Blob<Dtype>*>& top,
        const bool propagate_down, vector<Blob<Dtype>*>* bottom) {
    caffe_cpu_axpby(
        (*bottom)[0]->count(),              // count
        Dtype(1) / (*bottom)[0]->num(),     // alpha
        diff_.cpu_data(),                   // a
        Dtype(0),                           // beta
        (*bottom)[0]->mutable_cpu_diff());  // b
}