mlpack 4.6.2__cp313-cp313-win_amd64.whl → 4.7.0__cp313-cp313-win_amd64.whl

mlpack/include/mlpack/methods/ann/layer/grouped_convolution_impl.hpp

@@ -19,33 +19,33 @@
 namespace mlpack {
 
 template<
+    typename MatType,
     typename ForwardConvolutionRule,
     typename BackwardConvolutionRule,
-    typename GradientConvolutionRule,
-    typename MatType
+    typename GradientConvolutionRule
 >
-GroupedConvolutionType<
+GroupedConvolution<
+    MatType,
     ForwardConvolutionRule,
     BackwardConvolutionRule,
-    GradientConvolutionRule,
-    MatType
->::GroupedConvolutionType() : Layer<MatType>()
+    GradientConvolutionRule
+>::GroupedConvolution() : Layer<MatType>()
 {
   // Nothing to do here.
 }
 
 template<
+    typename MatType,
     typename ForwardConvolutionRule,
     typename BackwardConvolutionRule,
-    typename GradientConvolutionRule,
-    typename MatType
+    typename GradientConvolutionRule
 >
-GroupedConvolutionType<
+GroupedConvolution<
+    MatType,
     ForwardConvolutionRule,
     BackwardConvolutionRule,
-    GradientConvolutionRule,
-    MatType
->::GroupedConvolutionType(
+    GradientConvolutionRule
+>::GroupedConvolution(
     const size_t maps,
     const size_t kernelWidth,
     const size_t kernelHeight,
@@ -56,7 +56,7 @@ GroupedConvolutionType<
     const size_t padH,
     const std::string& paddingType,
     const bool useBias) :
-    GroupedConvolutionType(
+    GroupedConvolution(
       maps,
       kernelWidth,
       kernelHeight,
@@ -72,17 +72,17 @@ GroupedConvolutionType<
 }
 
 template<
+    typename MatType,
     typename ForwardConvolutionRule,
     typename BackwardConvolutionRule,
-    typename GradientConvolutionRule,
-    typename MatType
+    typename GradientConvolutionRule
 >
-GroupedConvolutionType<
+GroupedConvolution<
+    MatType,
     ForwardConvolutionRule,
     BackwardConvolutionRule,
-    GradientConvolutionRule,
-    MatType
->::GroupedConvolutionType(
+    GradientConvolutionRule
+>::GroupedConvolution(
     const size_t maps,
     const size_t kernelWidth,
     const size_t kernelHeight,
@@ -111,17 +111,17 @@ GroupedConvolutionType<
 }
 
 template<
+    typename MatType,
     typename ForwardConvolutionRule,
     typename BackwardConvolutionRule,
-    typename GradientConvolutionRule,
-    typename MatType
+    typename GradientConvolutionRule
 >
-GroupedConvolutionType<
+GroupedConvolution<
+    MatType,
     ForwardConvolutionRule,
     BackwardConvolutionRule,
-    GradientConvolutionRule,
-    MatType
->::GroupedConvolutionType(const GroupedConvolutionType& other) :
+    GradientConvolutionRule
+>::GroupedConvolution(const GroupedConvolution& other) :
     Layer<MatType>(other),
     maps(other.maps),
     kernelWidth(other.kernelWidth),
@@ -146,17 +146,17 @@ GroupedConvolutionType<
 }
 
 template<
+    typename MatType,
     typename ForwardConvolutionRule,
     typename BackwardConvolutionRule,
-    typename GradientConvolutionRule,
-    typename MatType
+    typename GradientConvolutionRule
 >
-GroupedConvolutionType<
+GroupedConvolution<
+    MatType,
     ForwardConvolutionRule,
     BackwardConvolutionRule,
-    GradientConvolutionRule,
-    MatType
->::GroupedConvolutionType(GroupedConvolutionType&& other) :
+    GradientConvolutionRule
+>::GroupedConvolution(GroupedConvolution&& other) :
     Layer<MatType>(std::move(other)),
     maps(std::move(other.maps)),
     kernelWidth(std::move(other.kernelWidth)),
@@ -181,23 +181,23 @@ GroupedConvolutionType<
 }
 
 template<
+    typename MatType,
     typename ForwardConvolutionRule,
     typename BackwardConvolutionRule,
-    typename GradientConvolutionRule,
-    typename MatType
+    typename GradientConvolutionRule
 >
-GroupedConvolutionType<
+GroupedConvolution<
+    MatType,
     ForwardConvolutionRule,
     BackwardConvolutionRule,
-    GradientConvolutionRule,
-    MatType
+    GradientConvolutionRule
 >&
-GroupedConvolutionType<
+GroupedConvolution<
+    MatType,
     ForwardConvolutionRule,
     BackwardConvolutionRule,
-    GradientConvolutionRule,
-    MatType
->::operator=(const GroupedConvolutionType& other)
+    GradientConvolutionRule
+>::operator=(const GroupedConvolution& other)
 {
   if (&other != this)
   {
@@ -226,23 +226,23 @@ GroupedConvolutionType<
 }
 
 template<
+    typename MatType,
     typename ForwardConvolutionRule,
     typename BackwardConvolutionRule,
-    typename GradientConvolutionRule,
-    typename MatType
+    typename GradientConvolutionRule
 >
-GroupedConvolutionType<
+GroupedConvolution<
+    MatType,
     ForwardConvolutionRule,
     BackwardConvolutionRule,
-    GradientConvolutionRule,
-    MatType
+    GradientConvolutionRule
 >&
-GroupedConvolutionType<
+GroupedConvolution<
+    MatType,
     ForwardConvolutionRule,
     BackwardConvolutionRule,
-    GradientConvolutionRule,
-    MatType
->::operator=(GroupedConvolutionType&& other)
+    GradientConvolutionRule
+>::operator=(GroupedConvolution&& other)
 {
   if (&other != this)
   {
@@ -271,16 +271,16 @@ GroupedConvolutionType<
 }
 
 template<
+    typename MatType,
     typename ForwardConvolutionRule,
     typename BackwardConvolutionRule,
-    typename GradientConvolutionRule,
-    typename MatType
+    typename GradientConvolutionRule
 >
-void GroupedConvolutionType<
+void GroupedConvolution<
+    MatType,
     ForwardConvolutionRule,
     BackwardConvolutionRule,
-    GradientConvolutionRule,
-    MatType
+    GradientConvolutionRule
 >::SetWeights(const MatType& weightsIn)
 {
   MakeAlias(weight, weightsIn, kernelWidth, kernelHeight,
@@ -297,16 +297,16 @@ void GroupedConvolutionType<
 }
 
 template<
+    typename MatType,
     typename ForwardConvolutionRule,
     typename BackwardConvolutionRule,
-    typename GradientConvolutionRule,
-    typename MatType
+    typename GradientConvolutionRule
 >
-void GroupedConvolutionType<
+void GroupedConvolution<
+    MatType,
     ForwardConvolutionRule,
     BackwardConvolutionRule,
-    GradientConvolutionRule,
-    MatType
+    GradientConvolutionRule
 >::Forward(const MatType& input, MatType& output)
 {
   batchSize = input.n_cols;
@@ -323,10 +323,6 @@ void GroupedConvolutionType<
     padding.Forward(input, inputPadded);
   }
 
-  CubeType inputTemp;
-  MakeAlias(inputTemp, (usingPadding ? inputPadded : input),
-      paddedRows, paddedCols, inMaps * higherInDimensions * batchSize);
-
   MakeAlias(outputTemp, output, this->outputDimensions[0],
       this->outputDimensions[1], maps * higherInDimensions * batchSize);
   outputTemp.zeros();
@@ -339,53 +335,60 @@ void GroupedConvolutionType<
   //
   // If we eventually have a way to do convolutions for a single kernel
   // in-batch, then this strategy may not be the most efficient solution.
+  #pragma omp parallel for schedule(dynamic)
   for (size_t offset = 0; offset < (higherInDimensions * batchSize); ++offset)
   {
     const size_t fullInputOffset = offset * inMaps;
     const size_t fullOutputOffset = offset * maps;
 
-    #pragma omp parallel for collapse(2)
+    CubeType inputTemp, weightTemp, outputTempTemp;
     for (size_t group = 0; group < groups; group++)
     {
-      // Iterate over output maps.
-      for (size_t outMap = 0; outMap < outGroupSize; ++outMap)
-      {
-        MatType& convOutput = outputTemp.slice(group * outGroupSize + outMap +
-            fullOutputOffset);
-        // Iterate over input maps (we will apply the filter and sum).
-        for (size_t inMap = 0; inMap < inGroupSize; ++inMap)
-        {
-          ForwardConvolutionRule::Convolution(
-              inputTemp.slice((group * inGroupSize) + inMap + fullInputOffset),
-              weight.slice(((group * outGroupSize + outMap) * inGroupSize) +
-                  inMap),
-              convOutput,
-              strideWidth,
-              strideHeight,
-              1,
-              1,
-              true);
-        }
+      MakeAlias(inputTemp, (usingPadding ? inputPadded : input), paddedRows,
+          paddedCols, inGroupSize, (group * inGroupSize + fullInputOffset) *
+          (paddedRows * paddedCols));
+      MakeAlias(weightTemp, weight, weight.n_rows, weight.n_cols,
+          inGroupSize * outGroupSize, (group * outGroupSize * inGroupSize) *
+          (weight.n_rows * weight.n_cols));
+      MakeAlias(outputTempTemp, outputTemp, outputTemp.n_rows,
+          outputTemp.n_cols, outGroupSize,
+          (group * outGroupSize + fullOutputOffset) *
+          (outputTemp.n_rows * outputTemp.n_cols));
+      ForwardConvolutionRule::Convolution(
+          inputTemp,
+          weightTemp,
+          outputTempTemp,
+          strideWidth,
+          strideHeight,
+          1,
+          1,
+          true);
+    }
 
-        // Make sure to add the bias.
-        if (useBias)
-          convOutput += bias(group * outGroupSize + outMap);
+    // Make sure to add the bias.
+    if (useBias)
+    {
+      for (size_t group = 0; group < groups; group++)
+      {
+        for (size_t outMap = 0; outMap < outGroupSize; ++outMap)
+          outputTemp.slice(group * outGroupSize + outMap + fullOutputOffset) +=
+              bias(group * outGroupSize + outMap);
       }
     }
   }
 }
 
 template<
+    typename MatType,
     typename ForwardConvolutionRule,
     typename BackwardConvolutionRule,
-    typename GradientConvolutionRule,
-    typename MatType
+    typename GradientConvolutionRule
 >
-void GroupedConvolutionType<
+void GroupedConvolution<
+    MatType,
     ForwardConvolutionRule,
     BackwardConvolutionRule,
-    GradientConvolutionRule,
-    MatType
+    GradientConvolutionRule
 >::Backward(
     const MatType& /* input */,
     const MatType& /* output */,
@@ -441,41 +444,39 @@ void GroupedConvolutionType<
 
   MatType output(apparentWidth * apparentHeight * inMaps * higherInDimensions,
       batchSize);
-  CubeType outputCube;
-  MakeAlias(outputCube, output, apparentWidth, apparentHeight,
-      inMaps * higherInDimensions * batchSize);
 
   size_t inGroupSize = inMaps / groups;
   size_t outGroupSize = maps / groups;
 
   // See Forward() for the overall iteration strategy.
+  #pragma omp parallel for schedule(dynamic) private(outputTemp)
   for (size_t offset = 0; offset < (higherInDimensions * batchSize); ++offset)
   {
     const size_t fullInputOffset = offset * inMaps;
     const size_t fullOutputOffset = offset * maps;
 
-    #pragma omp parallel for collapse(2)
+    CubeType rotatedFiltersTemp;
     for (size_t group = 0; group < groups; group++)
     {
-      // Iterate over input maps.
-      for (size_t inMap = 0; inMap < inGroupSize; ++inMap)
-      {
-        // Iterate over output maps.
-        MatType& curG = outputCube.slice((group * inGroupSize) + inMap +
-            fullInputOffset);
-        for (size_t outMap = group * outGroupSize; outMap < (group + 1) *
+      // Iterate over output maps.
+      for (size_t outMap = group * outGroupSize; outMap < (group + 1) *
             outGroupSize; ++outMap)
-        {
-          BackwardConvolutionRule::Convolution(
-              dilatedMappedError.slice(outMap + fullOutputOffset),
-              rotatedFilters.slice((outMap * inGroupSize) + inMap),
-              curG,
-              1,
-              1,
-              1,
-              1,
-              true);
-        }
+      {
+        MakeAlias(rotatedFiltersTemp, rotatedFilters, rotatedFilters.n_rows,
+            rotatedFilters.n_cols, inGroupSize, (outMap * inGroupSize) *
+            (rotatedFilters.n_rows * rotatedFilters.n_cols));
+        MakeAlias(outputTemp, output, apparentWidth, apparentHeight,
+            inGroupSize, (group * inGroupSize + fullInputOffset) *
+            (apparentWidth * apparentHeight));
+        BackwardConvolutionRule::Convolution(
+            dilatedMappedError.slice(outMap + fullOutputOffset),
+            rotatedFiltersTemp,
+            outputTemp,
+            1,
+            1,
+            1,
+            1,
+            true);
       }
     }
   }
@@ -501,25 +502,21 @@ void GroupedConvolutionType<
 }
 
 template<
+    typename MatType,
     typename ForwardConvolutionRule,
     typename BackwardConvolutionRule,
-    typename GradientConvolutionRule,
-    typename MatType
+    typename GradientConvolutionRule
 >
-void GroupedConvolutionType<
+void GroupedConvolution<
+    MatType,
     ForwardConvolutionRule,
     BackwardConvolutionRule,
-    GradientConvolutionRule,
-    MatType
+    GradientConvolutionRule
 >::Gradient(
     const MatType& input,
     const MatType& error,
     MatType& gradient)
 {
-  CubeType mappedError;
-  MakeAlias(mappedError, error, this->outputDimensions[0],
-      this->outputDimensions[1], higherInDimensions * maps * batchSize);
-
   // We are depending here on `inputPadded` being properly set from a call to
   // Forward().
   const bool usingPadding =
@@ -527,10 +524,6 @@ void GroupedConvolutionType<
   const size_t paddedRows = this->inputDimensions[0] + padWLeft + padWRight;
   const size_t paddedCols = this->inputDimensions[1] + padHTop + padHBottom;
 
-  CubeType inputTemp;
-  MakeAlias(inputTemp, (usingPadding ? inputPadded : input),
-      paddedRows, paddedCols, inMaps * batchSize, 0, false);
-
   MatType temp(apparentWidth * apparentHeight * inMaps * higherInDimensions,
       batchSize);
   CubeType tempCube;
@@ -549,40 +542,54 @@ void GroupedConvolutionType<
   size_t inGroupSize = inMaps / groups;
   size_t outGroupSize = maps / groups;
 
+  MatType tempSlice;
+
   // See Forward() for our iteration strategy.
+  #pragma omp parallel for schedule(dynamic) private(tempSlice)
   for (size_t offset = 0; offset < higherInDimensions * batchSize; ++offset)
   {
     const size_t fullInputOffset = offset * inMaps;
     const size_t fullOutputOffset = offset * maps;
 
-    #pragma omp parallel for collapse(2)
+    CubeType mappedError, gradientTempTemp;
     for (size_t group = 0; group < groups; group++)
     {
-      // Iterate over output maps.
-      for (size_t outMap = 0; outMap < outGroupSize; ++outMap)
+      MakeAlias(mappedError, error, this->outputDimensions[0],
+          this->outputDimensions[1], outGroupSize,
+          (group * outGroupSize + fullOutputOffset) *
+          (this->outputDimensions[0] * this->outputDimensions[1]));
+      // Iterate over input maps (we will apply the filter and sum).
+      for (size_t inMap = 0; inMap < inGroupSize; ++inMap)
       {
-        // Iterate over input maps (we will apply the filter and sum).
-        MatType& curError = mappedError.slice(group * outGroupSize + outMap +
-            fullOutputOffset);
-        for (size_t inMap = 0; inMap < inGroupSize; ++inMap)
+        MakeAlias(tempSlice, (usingPadding ? inputPadded : input), paddedRows,
+            paddedCols, ((group * inGroupSize) + inMap + fullInputOffset) *
+            (paddedRows * paddedCols));
+        GradientConvolutionRule::Convolution(
+            tempSlice,
+            mappedError,
+            gradientTempTemp,
+            1,
+            1,
+            strideWidth,
+            strideHeight,
+            false);
+
+        // Reorder convolution output slices.
+        #pragma omp critical
+        for (size_t outMap = 0; outMap < outGroupSize; ++outMap)
         {
-          MatType output;
-          GradientConvolutionRule::Convolution(
-              tempCube.slice((group * inGroupSize) + inMap + fullInputOffset),
-              curError,
-              gradientTemp.slice(((group * outGroupSize + outMap) *
-                  inGroupSize) + inMap),
-              1,
-              1,
-              strideWidth,
-              strideHeight,
-              true);
+          gradientTemp.slice((group * outGroupSize + outMap) * inGroupSize +
+              inMap) += gradientTempTemp.slice(outMap);
         }
+      }
 
-        if (useBias)
+      if (useBias)
+      {
+        for (size_t outMap = 0; outMap < outGroupSize; ++outMap)
         {
+          #pragma omp atomic update
           gradient[weight.n_elem + group * outGroupSize + outMap] +=
-              accu(curError);
+              accu(mappedError.slice(outMap));
         }
       }
     }
@@ -590,16 +597,16 @@ void GroupedConvolutionType<
 }
 
 template<
+    typename MatType,
     typename ForwardConvolutionRule,
     typename BackwardConvolutionRule,
-    typename GradientConvolutionRule,
-    typename MatType
+    typename GradientConvolutionRule
 >
-void GroupedConvolutionType<
+void GroupedConvolution<
+    MatType,
     ForwardConvolutionRule,
     BackwardConvolutionRule,
-    GradientConvolutionRule,
-    MatType
+    GradientConvolutionRule
 >::ComputeOutputDimensions()
 {
   // First, we must make sure the padding sizes are up to date, which we can
@@ -616,7 +623,7 @@ void GroupedConvolutionType<
     InitializeSamePadding();
   }
 
-  padding = PaddingType<MatType>(padWLeft, padWRight, padHTop, padHBottom);
+  padding = Padding<MatType>(padWLeft, padWRight, padHTop, padHBottom);
   padding.InputDimensions() = this->inputDimensions;
   padding.ComputeOutputDimensions();
 
@@ -654,7 +661,7 @@ void GroupedConvolutionType<
   apparentHeight = (this->outputDimensions[1] - 1) * strideHeight +
       kernelHeight;
 
-  paddingBackward = PaddingType<MatType>(0, padding.OutputDimensions()[0] -
+  paddingBackward = Padding<MatType>(0, padding.OutputDimensions()[0] -
       apparentWidth, 0, padding.OutputDimensions()[1] - apparentHeight);
   paddingBackward.InputDimensions() = std::vector<size_t>({ apparentWidth,
       apparentHeight, inMaps * higherInDimensions });
@@ -664,17 +671,17 @@ void GroupedConvolutionType<
 }
 
 template<
+    typename MatType,
     typename ForwardConvolutionRule,
     typename BackwardConvolutionRule,
-    typename GradientConvolutionRule,
-    typename MatType
+    typename GradientConvolutionRule
 >
 template<typename Archive>
-void GroupedConvolutionType<
+void GroupedConvolution<
+    MatType,
     ForwardConvolutionRule,
     BackwardConvolutionRule,
-    GradientConvolutionRule,
-    MatType
+    GradientConvolutionRule
 >::serialize(Archive& ar, const uint32_t /* version*/)
 {
   ar(cereal::base_class<Layer<MatType>>(this));
@@ -698,16 +705,16 @@ void GroupedConvolutionType<
 }
 
 template<
+    typename MatType,
     typename ForwardConvolutionRule,
     typename BackwardConvolutionRule,
-    typename GradientConvolutionRule,
-    typename MatType
+    typename GradientConvolutionRule
 >
-void GroupedConvolutionType<
+void GroupedConvolution<
+    MatType,
     ForwardConvolutionRule,
     BackwardConvolutionRule,
-    GradientConvolutionRule,
-    MatType
+    GradientConvolutionRule
 >::InitializeSamePadding()
 {
   /*