Add group argument in ConvFunctionBase

paddle/function/ConvOp.h

@@ -38,6 +38,7 @@ public:
     // function arguments
     strides_ = config.get<std::vector<size_t>>("strides");
     paddings_ = config.get<std::vector<size_t>>("paddings");
+    groups_ = config.get<size_t>("groups");
 
     // number of inputs and outputs
     numInputs_ = 2;
@@ -62,6 +63,11 @@ public:
 protected:
   std::vector<size_t> strides_;
   std::vector<size_t> paddings_;
+  /// Group size, refer to grouped convolution in
+  /// Alex Krizhevsky's paper: when group=2, the first half of the
+  /// filters are only connected to the first half of the input channels,
+  /// and the second half only connected to the second half.
+  size_t groups_;
   inline int strideH() const { return strides_[0]; }
 
   inline int strideW() const { return strides_[1]; }

paddle/function/ConvOpTest.cpp

@@ -55,6 +55,7 @@ public:
                                            FuncConfig()
                                                .set("paddings", paddings)
                                                .set("strides", strides)
+                                               .set("groups", (size_t)1)
                                                .set("algo", algo));
 
                   TensorShape shape0{

paddle/function/GemmConvOp.cpp

@@ -101,19 +101,26 @@ public:
     size_t outputHeight = outputs[0].shape()[2];
     size_t outputWidth = outputs[0].shape()[3];
 
+    CHECK_EQ(inputChannels / groups_, inputs[1].shape()[1]);
+
     real* inputData = inputs[0].data<real>();
     real* filterData = inputs[1].data<real>();
     real* outputData = outputs[0].data<real>();
 
-    size_t size =
-        inputChannels * filterHeight * filterWidth * outputHeight * outputWidth;
+    size_t size = inputChannels / groups_ * filterHeight * filterWidth *
+                  outputHeight * outputWidth;
     resizeBuffer(size);
     real* colData = reinterpret_cast<real*>(memory_->getBuf());
 
     Im2ColFunctor<real> im2col;
+    size_t inputOffset = (inputChannels / groups_) * inputHeight * inputWidth;
+    size_t outputOffset =
+        (outputChannels / groups_) * outputHeight * outputWidth;
+    size_t filterOffset = inputs[1].shape().getElements() / groups_;
     for (size_t i = 0; i < batchSize; i++) {
-      im2col(inputData,
-             inputChannels,
+      for (int g = 0; g < groups_; g++) {
+        im2col(inputData + g * inputOffset,
+               inputChannels / groups_,
                inputHeight,
                inputWidth,
                filterHeight,
@@ -135,17 +142,18 @@ public:
                    N,
                    K,
                    1.0f,
-                 filterData,
+                   filterData + g * filterOffset,
                    K,
                    colData,
                    N,
                    0.0f,
-                 outputData,
+                   outputData + g * outputOffset,
                    N);
         inputData += inputChannels * inputHeight * inputWidth;
         outputData += outputChannels * outputHeight * outputWidth;
       }
     }
+  }
 
   void resizeBuffer(size_t newSize) {
     if (!memory_ || newSize * sizeof(real) > memory_->getAllocSize()) {