Merge remote-tracking branch 'origin/master'

Author: rbgirshick

Makefile

@@ -49,7 +49,7 @@ PROTO_GEN_HEADER := ${PROTO_SRCS:.proto=.pb.h}
 PROTO_GEN_CC := ${PROTO_SRCS:.proto=.pb.cc}
 PROTO_GEN_PY := ${PROTO_SRCS:.proto=_pb2.py}
 # The objects corresponding to the source files
-# These objects will be linked into the final shared library, so we 
+# These objects will be linked into the final shared library, so we
 # exclude the test and example objects.
 CXX_OBJS := ${CXX_SRCS:.cpp=.o}
 CU_OBJS := ${CU_SRCS:.cu=.cuo}
@@ -84,7 +84,7 @@ CXXFLAGS += -pthread -fPIC -O2 $(COMMON_FLAGS)
 NVCCFLAGS := -Xcompiler -fPIC -O2 $(COMMON_FLAGS)
 LDFLAGS += $(foreach librarydir,$(LIBRARY_DIRS),-L$(librarydir)) \
 		$(foreach library,$(LIBRARIES),-l$(library)) \
-		-Wl,-rpath,../libs/
+		-Wl,-rpath,../lib/
 PYTHON_LDFLAGS := $(LDFLAGS) $(foreach library,$(PYTHON_LIBRARIES),-l$(library))
 
 

python/caffe/pycaffe.cpp

@@ -91,6 +91,51 @@ struct CaffeNet
     }
   }
 
+  void Backward(list top_diff, list bottom_diff) {
+    vector<Blob<float>*>& output_blobs = net_->output_blobs();
+    vector<Blob<float>*>& input_blobs = net_->input_blobs();
+    CHECK_EQ(len(bottom_diff), input_blobs.size());
+    CHECK_EQ(len(top_diff), output_blobs.size());
+    // First, copy the output diff
+    for (int i = 0; i < output_blobs.size(); ++i) {
+      object elem = top_diff[i];
+      PyArrayObject* arr = reinterpret_cast<PyArrayObject*>(elem.ptr());
+      check_array_against_blob(arr, output_blobs[i]);
+      switch (Caffe::mode()) {
+      case Caffe::CPU:
+        memcpy(output_blobs[i]->mutable_cpu_diff(), PyArray_DATA(arr),
+            sizeof(float) * output_blobs[i]->count());
+        break;
+      case Caffe::GPU:
+        cudaMemcpy(output_blobs[i]->mutable_gpu_diff(), PyArray_DATA(arr),
+            sizeof(float) * output_blobs[i]->count(), cudaMemcpyHostToDevice);
+        break;
+      default:
+        LOG(FATAL) << "Unknown Caffe mode.";
+      }  // switch (Caffe::mode())
+    }
+    //LOG(INFO) << "Start";
+    net_->Backward();
+    //LOG(INFO) << "End";
+    for (int i = 0; i < input_blobs.size(); ++i) {
+      object elem = bottom_diff[i];
+      PyArrayObject* arr = reinterpret_cast<PyArrayObject*>(elem.ptr());
+      check_array_against_blob(arr, input_blobs[i]);
+      switch (Caffe::mode()) {
+      case Caffe::CPU:
+        memcpy(PyArray_DATA(arr), input_blobs[i]->cpu_diff(),
+            sizeof(float) * input_blobs[i]->count());
+        break;
+      case Caffe::GPU:
+        cudaMemcpy(PyArray_DATA(arr), input_blobs[i]->gpu_diff(),
+            sizeof(float) * input_blobs[i]->count(), cudaMemcpyDeviceToHost);
+        break;
+      default:
+        LOG(FATAL) << "Unknown Caffe mode.";
+      }  // switch (Caffe::mode())
+    }
+  }
+
   // The caffe::Caffe utility functions.
   void set_mode_cpu() { Caffe::set_mode(Caffe::CPU); }
   void set_mode_gpu() { Caffe::set_mode(Caffe::GPU); }
@@ -108,11 +153,12 @@ BOOST_PYTHON_MODULE(pycaffe)
 {
   boost::python::class_<CaffeNet>(
       "CaffeNet", boost::python::init<string, string>())
-      .def("Forward", &CaffeNet::Forward)
-      .def("set_mode_cpu", &CaffeNet::set_mode_cpu)
-      .def("set_mode_gpu", &CaffeNet::set_mode_gpu)
+      .def("Forward",         &CaffeNet::Forward)
+      .def("Backward",        &CaffeNet::Backward)
+      .def("set_mode_cpu",    &CaffeNet::set_mode_cpu)
+      .def("set_mode_gpu",    &CaffeNet::set_mode_gpu)
       .def("set_phase_train", &CaffeNet::set_phase_train)
-      .def("set_phase_test", &CaffeNet::set_phase_test)
-      .def("set_device", &CaffeNet::set_device)
+      .def("set_phase_test",  &CaffeNet::set_phase_test)
+      .def("set_device",      &CaffeNet::set_device)
   ;
 }

src/caffe/net.cpp

@@ -47,7 +47,7 @@ void Net<Dtype>::Init(const NetParameter& param) {
                         param.input_dim(i * 4 + 3)));
     blobs_.push_back(blob_pointer);
     blob_names_.push_back(blob_name);
-    blob_need_backward_.push_back(false);
+    blob_need_backward_.push_back(param.force_backward());
     net_input_blob_indices_.push_back(i);
     net_input_blobs_.push_back(blob_pointer.get());
     blob_name_to_idx[blob_name] = i;
@@ -64,7 +64,7 @@ void Net<Dtype>::Init(const NetParameter& param) {
     layers_.push_back(shared_ptr<Layer<Dtype> >(GetLayer<Dtype>(layer_param)));
     layer_names_.push_back(layer_param.name());
     LOG(INFO) << "Creating Layer " << layer_param.name();
-    bool need_backward = false;
+    bool need_backward = param.force_backward();
     // Figure out this layer's input and output
     for (int j = 0; j < layer_connection.bottom_size(); ++j) {
       const string& blob_name = layer_connection.bottom(j);
@@ -102,7 +102,7 @@ void Net<Dtype>::Init(const NetParameter& param) {
         shared_ptr<Blob<Dtype> > blob_pointer(new Blob<Dtype>());
         blobs_.push_back(blob_pointer);
         blob_names_.push_back(blob_name);
-        blob_need_backward_.push_back(false);
+        blob_need_backward_.push_back(param.force_backward());
         blob_name_to_idx[blob_name] = blob_names_.size() - 1;
         available_blobs.insert(blob_name);
         top_vecs_[i].push_back(blobs_[blob_names_.size() - 1].get());

src/caffe/proto/caffe.proto

@@ -108,6 +108,10 @@ message NetParameter {
   // values specifying the num, channels, height and width of the input blob.
   // Thus, there should be a total of (4 * #input) numbers.
   repeated int32 input_dim = 4;
+  // Whether the network will force every layer to carry out backward operation.
+  // If set False, then whether to carry out backward is determined
+  // automatically according to the net structure and learning rates.
+  optional bool force_backward = 5 [ default = false ];
 }
 
 message SolverParameter {