在caffe中添加样本扩增的功能

在caffe-cudnn 中添加样本扩增的功能

有个样本扩增的代码。可以run

考虑到我的caffe的版本太多了。所以把所有的功能都merge 到一起。

首先merge 的是样本扩增的功能。

因为只有在imagedata 层里面用到样本扩增。里面用到了data_transfer 这一层。

data_transfer 这一层有四个函数。

我们只需要重载：

template<typename Dtype>

void DataTransformer<Dtype>::Transform(const cv::Mat& img, Blob<Dtype>* transformed_blob)

改成下面的code。

template<typename Dtype>
void DataTransformer<Dtype>::Transform(const cv::Mat& img,
                                       Blob<Dtype>* transformed_blob) {
  cv::Mat cv_img;
  img.copyTo(cv_img);									   
  const int crop_size = param_.crop_size();
  const bool display = param_.display();
  const bool contrast_adjustment = param_.contrast_adjustment();
  const bool smooth_filtering = param_.smooth_filtering();
  const bool jpeg_compression = param_.jpeg_compression();


  const int img_channels = cv_img.channels();
  const int img_height = cv_img.rows;
  const int img_width = cv_img.cols;

  // Check dimensions.
  const int channels = transformed_blob->channels();
  const int height = transformed_blob->height();
  const int width = transformed_blob->width();
  const int num = transformed_blob->num();

  CHECK_EQ(channels, img_channels);
  CHECK_LE(height, img_height);
  CHECK_LE(width, img_width);
  CHECK_GE(num, 1);

  CHECK(cv_img.depth() == CV_8U) << "Image data type must be unsigned byte";

  const Dtype scale = param_.scale();
  //const bool do_mirror = param_.mirror() && Rand(2);
  const bool has_mean_file = param_.has_mean_file();
  const bool has_mean_values = mean_values_.size() > 0;

  CHECK_GT(img_channels, 0);
  CHECK_GE(img_height, crop_size);
  CHECK_GE(img_width, crop_size);

  // param for rotation
  const float rotation_angle_interval = param_.rotation_angle_interval();


  if (display && phase_ == TRAIN)
	  cv::imshow("Source", cv_img);

  // Flipping and Reflection -----------------------------------------------------------------
	int flipping_mode = (Rand(4)) - 1; // -1, 0, 1, 2
	bool apply_flipping = (flipping_mode != 2);
	if (apply_flipping) {
		cv::flip(cv_img,cv_img,flipping_mode);
		if (display && phase_ == TRAIN)
			cv::imshow("Flipping and Reflection", cv_img);
	}


  // Smooth Filtering -------------------------------------------------------------
  int smooth_param1 = 3;
  int apply_smooth = Rand(2);
  if ( smooth_filtering && apply_smooth ) {
	int smooth_type = Rand(4); // see opencv_util.hpp
	smooth_param1 = 3 + 2*(Rand(1));
        switch(smooth_type){
        case 0:
	   //cv::Smooth(cv_img, cv_img, smooth_type, smooth_param1);
	   cv::GaussianBlur(cv_img, cv_img, cv::Size(smooth_param1,smooth_param1),0);
           break;
        case 1:
           cv::blur(cv_img, cv_img, cv::Size(smooth_param1,smooth_param1));
           break;
        case 2:
           cv::medianBlur(cv_img, cv_img, smooth_param1);
           break;
        case 3:
           cv::boxFilter(cv_img, cv_img, -1, cv::Size(smooth_param1*2,smooth_param1*2));
           break;
        }
	if (display && phase_ == TRAIN)
      cv::imshow("Smooth Filtering", cv_img);
  }
  cv::RNG rng;
  // Contrast and Brightness Adjuestment ----------------------------------------
  float alpha = 1, beta = 0;
  int apply_contrast = Rand(2);
  if ( contrast_adjustment && apply_contrast ) {
    float min_alpha = 0.8, max_alpha = 1.2;
    alpha = rng.uniform(min_alpha, max_alpha);
    beta = (float)(Rand(6));
	// flip sign
	if ( Rand(2) ) beta = - beta;
    cv_img.convertTo(cv_img, -1 , alpha, beta);
	if (display && phase_ == TRAIN)
     		cv::imshow("Contrast Adjustment", cv_img);
  }
   LOG(INFO) << "JPEG Compression";
  // JPEG Compression -------------------------------------------------------------
  // DO NOT use the following code as there is some memory leak which I cann't figure out
  int QF = 100;
  int apply_JPEG = Rand(2);
  if ( jpeg_compression && apply_JPEG ) {
	// JPEG quality factor
	QF = 95 + 1 * (Rand(6));
        int cp[] = {1, QF};
	vector<int> compression_params(cp,cp + 2);
        vector<unsigned char> img_jpeg;
	//cv::imencode(".jpg", cv_img, img_jpeg);
        cv::imencode(".jpg", cv_img, img_jpeg, compression_params);
	cv::Mat temp = cv::imdecode(img_jpeg, 1);
        temp.copyTo(cv_img);
	if (display && phase_ == TRAIN)
      cv::imshow("JPEG Compression", cv_img);
  }
   LOG(INFO) << "crop";
  // Cropping -------------------------------------------------------------
  int h_off = 0;
  int w_off = 0;
  cv::Mat cv_cropped_img = cv_img;
  if (crop_size) {
    CHECK_EQ(crop_size, height);
    CHECK_EQ(crop_size, width);
    // We only do random crop when we do training.
    if (phase_ == TRAIN) {
      h_off = Rand(img_height - crop_size + 1);
      w_off = Rand(img_width - crop_size + 1);
    } else {
      h_off = (img_height - crop_size) / 2;
      w_off = (img_width - crop_size) / 2;
    }
    cv::Rect roi(w_off, h_off, crop_size, crop_size);
    cv_cropped_img = cv_img(roi);
    if (display && phase_ == TRAIN)
    	cv::imshow("Cropping", cv_cropped_img);
  } else {
    CHECK_EQ(img_height, height);
    CHECK_EQ(img_width, width);
  }


  // Rotation -------------------------------------------------------------
  double rotation_degree;
  if ( rotation_angle_interval!=1 ) {
  cv::Mat dst;
  int interval = 360/rotation_angle_interval;
  int apply_rotation = Rand(interval);

  cv::Size dsize = cv::Size(cv_cropped_img.cols*1.5,cv_cropped_img.rows*1.5);
  cv::Mat resize_img = cv::Mat(dsize,CV_32S);
  cv::resize(cv_cropped_img, resize_img,dsize);

  cv::Point2f pt(resize_img.cols/2., resize_img.rows/2.);    
  rotation_degree = apply_rotation*rotation_angle_interval;
  cv::Mat r = getRotationMatrix2D(pt, rotation_degree, 1.0);
  warpAffine(resize_img, dst, r, cv::Size(resize_img.cols, resize_img.rows));


  cv::Rect myROI(resize_img.cols/6, resize_img.rows/6, cv_cropped_img.cols, cv_cropped_img.rows);
  cv::Mat crop_after_rotate = dst(myROI);
  if (display && phase_ == TRAIN)
      cv::imshow("Rotation", crop_after_rotate);


  crop_after_rotate.copyTo(cv_img);
  }
  
  if (display && phase_ == TRAIN)
      cv::imshow("Final", cv_img);


  

  //--------------------!! for debug only !!-------------------
  if (display && phase_ == TRAIN) {
	LOG(INFO) << "----------------------------------------";
	LOG(INFO) << "src width: " << width << ", src height: " << height;
	LOG(INFO) << "dest width: " << crop_size << ", dest height: " << crop_size;
	if (apply_flipping) {
		LOG(INFO) << "* parameter for flipping: ";
		LOG(INFO) << "  flipping_mode: " << flipping_mode;
	}
	if ( smooth_filtering && apply_smooth ) {
          LOG(INFO) << "* parameter for smooth filtering: ";
	  //LOG(INFO) << "  smooth type: " << smooth_type << ", smooth param1: " << smooth_param1;
	}
	if ( contrast_adjustment && apply_contrast ) {
	  LOG(INFO) << "* parameter for contrast adjustment: ";
	  LOG(INFO) << "  alpha: " << alpha << ", beta: " << beta;
	}
	if ( jpeg_compression && apply_JPEG ) {
	  LOG(INFO) << "* parameter for JPEG compression: ";
	  LOG(INFO) << "  QF: " << QF;
	}
	LOG(INFO) << "* parameter for cropping: ";
	LOG(INFO) << "  w: " << w_off << ", h: " << h_off;
	LOG(INFO) << "  roi_width: " << crop_size << ", roi_height: " << crop_size;
	LOG(INFO) << "* parameter for rotation: ";
	LOG(INFO) << "  angle_interval: " << rotation_angle_interval;
	LOG(INFO) << "  angle: " << rotation_degree;
    cvWaitKey(10);
  }

  Dtype* mean = NULL;
  if (has_mean_file) {
    CHECK_EQ(img_channels, data_mean_.channels());
    CHECK_EQ(img_height, data_mean_.height());
    CHECK_EQ(img_width, data_mean_.width());
    mean = data_mean_.mutable_cpu_data();
  }
  
   if (has_mean_values) {
    CHECK(mean_values_.size() == 1 || mean_values_.size() == img_channels) <<
     "Specify either 1 mean_value or as many as channels: " << img_channels;
    if (img_channels > 1 && mean_values_.size() == 1) {
      // Replicate the mean_value for simplicity
      for (int c = 1; c < img_channels; ++c) {
        mean_values_.push_back(mean_values_[0]);
      }
    }
  }
  
  Dtype* transformed_data = transformed_blob->mutable_cpu_data();
  int top_index;
  for (int h = 0; h < height; ++h) {
    const uchar* ptr = cv_img.ptr<uchar>(h); // here!!
    int img_index = 0;
    for (int w = 0; w < width; ++w) {
      for (int c = 0; c < img_channels; ++c) {
        //if (do_mirror) {
        //  top_index = (c * height + h) * width + (width - 1 - w);
        //} else {
          top_index = (c * height + h) * width + w;
        //}
        // int top_index = (c * height + h) * width + w;
        Dtype pixel = static_cast<Dtype>(ptr[img_index++]);
        if (has_mean_file) {
          int mean_index = (c * img_height + h) * img_width + w;
          transformed_data[top_index] =
            (pixel - mean[mean_index]) * scale;
        } else {
          if (has_mean_values) {
            transformed_data[top_index] =
              (pixel - mean_values_[c]) * scale;
          } else {
            transformed_data[top_index] = pixel * scale;
          }
        }
      }
    }
  }

}

同时在caffe.proto 把transformer 层改成：
message TransformationParameter {
  // For data pre-processing, we can do simple scaling and subtracting the
  // data mean, if provided. Note that the mean subtraction is always carried
  // out before scaling.
  optional float scale = 1 [default = 1];
  // Specify if we want to randomly mirror data.
  optional bool mirror = 2 [default = false];
  // Specify if we would like to randomly crop an image.
  optional uint32 crop_size = 3 [default = 0];
  // mean_file and mean_value cannot be specified at the same time
  optional string mean_file = 4;
  // if specified can be repeated once (would subtract it from all the channels)
  // or can be repeated the same number of times as channels
  // (would subtract them from the corresponding channel)
  repeated float mean_value = 5;
  // Force the decoded image to have 3 color channels.
  optional bool force_color = 6 [default = false];
  // Force the decoded image to have 1 color channels.
  optional bool force_gray = 7 [default = false];
   // change by ggj 20170331
  optional bool self_preprocess = 15 [default = false];
    // Specify the range of scaling factor for doing resizing 

   // 下面的部分是需要添加的部分
  optional float min_scaling_factor = 8 [default = 0.75];
  optional float max_scaling_factor = 9 [default = 1.50];
  // Specify the angle interval for doing rotation
  optional float rotation_angle_interval = 10 [default = 1];
  optional bool contrast_adjustment = 11 [default = false];
  optional bool smooth_filtering = 12 [default = false];
  optional bool jpeg_compression = 13 [default = false];
  optional bool display = 14 [default = false];
}

然后make clean && make all -j8 如果报错，就按照错误一步步看下去，看哪里出现问题，然后改掉