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

mlpack/include/mlpack/methods/ann/convolution_rules/naive_convolution.hpp

@@ -13,14 +13,13 @@
 #ifndef MLPACK_METHODS_ANN_CONVOLUTION_RULES_NAIVE_CONVOLUTION_HPP
 #define MLPACK_METHODS_ANN_CONVOLUTION_RULES_NAIVE_CONVOLUTION_HPP
 
-#include <mlpack/prereqs.hpp>
-#include "border_modes.hpp"
+#include "base_convolution.hpp"
 
 namespace mlpack {
 
 /**
  * Computes the two-dimensional convolution. This class allows specification of
- * the type of the border type. The convolution can be compute with the valid
+ * the type of the border type. The convolution can be computed with the valid
  * border type of the full border type (default).
  *
  * FullConvolution: returns the full two-dimensional convolution.
@@ -31,115 +30,16 @@ namespace mlpack {
  * ValidConvolution).
  */
 template<typename BorderMode = FullConvolution>
-class NaiveConvolution
+class NaiveConvolution : public BaseConvolution<BorderMode>
 {
  public:
   /**
-   * Perform a convolution (valid mode).
-   *
-   * @param input Input used to perform the convolution.
-   * @param filter Filter used to perform the convolution.
-   * @param output Output data that contains the results of the convolution.
-   * @param dW Stride of filter application in the x direction.
-   * @param dH Stride of filter application in the y direction.
-   * @param dilationW The dilation factor in x direction.
-   * @param dilationH The dilation factor in y direction.
-   * @param appending If true, it will not initialize the output. Instead,
-   *                  it will append the results to the output.
-   */
-  template<typename InMatType, typename FilMatType, typename OutMatType,
-      typename Border = BorderMode>
-  static std::enable_if_t<std::is_same_v<Border, ValidConvolution>, void>
-  Convolution(const InMatType& input,
-              const FilMatType& filter,
-              OutMatType& output,
-              const size_t dW = 1,
-              const size_t dH = 1,
-              const size_t dilationW = 1,
-              const size_t dilationH = 1,
-              const bool appending = false,
-              const typename std::enable_if_t<IsMatrix<InMatType>::value>* = 0)
-  {
-    using eT = typename InMatType::elem_type;
-    // Compute the output size.  The filterRows and filterCols computation must
-    // take into account the fact that dilation only adds rows or columns
-    // *between* filter elements.  So, e.g., a dilation of 2 on a kernel size of
-    // 3x3 means an effective kernel size of 5x5, *not* 6x6.
-    if (!appending)
-    {
-      const size_t filterRows = filter.n_rows * dilationH - (dilationH - 1);
-      const size_t filterCols = filter.n_cols * dilationW - (dilationW - 1);
-      const size_t outputRows = (input.n_rows - filterRows + dH) / dH;
-      const size_t outputCols = (input.n_cols - filterCols + dW) / dW;
-      output.zeros(outputRows, outputCols);
-    }
-
-    // It seems to be about 3.5 times faster to use pointers instead of
-    // filter(ki, kj) * input(leftInput + ki, topInput + kj) and output(i, j).
-    eT* outputPtr = output.memptr();
-
-    for (size_t j = 0; j < output.n_cols; ++j)
-    {
-      for (size_t i = 0; i < output.n_rows; ++i, outputPtr++)
-      {
-        const eT* kernelPtr = filter.memptr();
-        for (size_t kj = 0; kj < filter.n_cols; ++kj)
-        {
-          const eT* inputPtr = input.colptr(kj * dilationW + j * dW) + i * dH;
-          for (size_t ki = 0; ki < filter.n_rows; ++ki, ++kernelPtr,
-              inputPtr += dilationH)
-            *outputPtr += *kernelPtr * (*inputPtr);
-        }
-      }
-    }
-  }
-
-  /**
-   * Perform a convolution (full mode).
-   *
-   * @param input Input used to perform the convolution.
-   * @param filter Filter used to perform the convolution.
-   * @param output Output data that contains the results of the convolution.
-   * @param dW Stride of filter application in the x direction.
-   * @param dH Stride of filter application in the y direction.
-   * @param dilationW The dilation factor in x direction.
-   * @param dilationH The dilation factor in y direction.
-   * @param appending If true, it will not initialize the output. Instead,
-   *                  it will append the results to the output.
-   */
-  template<typename InMatType, typename FilMatType, typename OutMatType,
-      typename Border = BorderMode>
-  static std::enable_if_t<std::is_same_v<Border, FullConvolution>, void>
-  Convolution(const InMatType& input,
-              const FilMatType& filter,
-              OutMatType& output,
-              const size_t dW = 1,
-              const size_t dH = 1,
-              const size_t dilationW = 1,
-              const size_t dilationH = 1,
-              const bool appending = false,
-              const typename std::enable_if_t<IsMatrix<InMatType>::value>* = 0)
-  {
-    // First, compute the necessary padding for the full convolution.  It is
-    // possible that this might be an overestimate.  Note that these variables
-    // only hold the padding on one side of the input.
-    const size_t filterRows = filter.n_rows * dilationH - (dilationH - 1);
-    const size_t filterCols = filter.n_cols * dilationW - (dilationW - 1);
-    const size_t paddingRows = filterRows - 1;
-    const size_t paddingCols = filterCols - 1;
-
-    // Pad filter and input to the working output shape.
-    InMatType inputPadded(input.n_rows + 2 * paddingRows,
-        input.n_cols + 2 * paddingCols);
-    inputPadded.submat(paddingRows, paddingCols, paddingRows + input.n_rows - 1,
-        paddingCols + input.n_cols - 1) = input;
-
-    NaiveConvolution<ValidConvolution>::Convolution(inputPadded, filter,
-        output, dW, dH, dilationW, dilationH, appending);
-  }
-
-  /**
-   * Perform a convolution using 3rd order tensors.
+   * Perform a convolution using 3rd order tensors. Expects that `filter` has
+   * `input.n_slices * output.n_slices` slices. The Nth `input.n_slices` filters
+   * are applied to all input slices and output to the Nth output slice.
+   * eg. 2 input slices: filter 0 applies to input 0, output 0,
+   * fil 1 * in 1 = out 0, fil 2 * in 0 = out 1, fil 3 * in 1 = out 1,
+   * fil 4 * in 0 = out 2, fil 5 * in 1 = out 2, etc.
    *
    * @param input Input used to perform the convolution.
    * @param filter Filter used to perform the convolution.
@@ -164,19 +64,26 @@ class NaiveConvolution
       const typename std::enable_if_t<IsCube<CubeType>::value>* = 0)
   {
     using MatType = typename GetDenseMatType<CubeType>::type;
-    MatType convOutput;
-    NaiveConvolution<BorderMode>::Convolution(input.slice(0), filter.slice(0),
-        convOutput, dW, dH, dilationW, dilationH, appending);
 
-    if (!appending)
-      output = CubeType(convOutput.n_rows, convOutput.n_cols, input.n_slices);
+    CubeType inputPadded;
+    NaiveConvolution::PadInput(input, filter, inputPadded, dilationW,
+        dilationH);
+
+    const size_t inMaps = input.n_slices;
+    const size_t outMaps = filter.n_slices / inMaps;
 
-    output.slice(0) = convOutput;
+    if (!appending)
+      NaiveConvolution::InitalizeOutput(inputPadded, filter, output, dW, dH,
+          dilationW, dilationH, outMaps);
 
-    for (size_t i = 1; i < input.n_slices; ++i)
+    for (size_t i = 0; i < inMaps; i++)
     {
-      NaiveConvolution<BorderMode>::Convolution(input.slice(i), filter.slice(i),
-          output.slice(i), dW, dH, dilationW, dilationH, appending);
+      MatType& inputSlice = inputPadded.slice(i);
+      for (size_t j = 0; j < outMaps; j++)
+      {
+        Conv2(inputSlice, filter.slice(j * inMaps + i), output.slice(j),
+            dW, dH, dilationW, dilationH);
+      }
     }
   }
 
@@ -207,25 +114,23 @@ class NaiveConvolution
       const typename std::enable_if_t<IsMatrix<MatType>::value>* = 0,
       const typename std::enable_if_t<IsCube<CubeType>::value>* = 0)
   {
-    MatType convOutput;
-    NaiveConvolution<BorderMode>::Convolution(input, filter.slice(0),
-        convOutput, dW, dH, dilationW, dilationH, appending);
+    MatType inputPadded;
+    NaiveConvolution::PadInput(input, filter, inputPadded, dilationW,
+        dilationH);
 
     if (!appending)
-      output = CubeType(convOutput.n_rows, convOutput.n_cols, filter.n_slices);
-
-    output.slice(0) = convOutput;
+      NaiveConvolution::InitalizeOutput(inputPadded, filter, output, dW, dH,
+          dilationW, dilationH, filter.n_slices);
 
-    for (size_t i = 1; i < filter.n_slices; ++i)
+    for (size_t s = 0; s < filter.n_slices; s++)
     {
-      NaiveConvolution<BorderMode>::Convolution(input, filter.slice(i),
-          output.slice(i), dW, dH, dilationW, dilationH, appending);
+      Conv2(inputPadded, filter.slice(s), output.slice(s), dW, dH,
+          dilationW, dilationH);
     }
   }
-
+ private:
   /**
-   * Perform a convolution using a 3rd order tensors as input and output and a
-   * dense matrix as filter.
+   * Perform a valid convolution.
    *
    * @param input Input used to perform the convolution.
    * @param filter Filter used to perform the convolution.
@@ -233,38 +138,88 @@ class NaiveConvolution
    * @param dW Stride of filter application in the x direction.
    * @param dH Stride of filter application in the y direction.
    * @param dilationW The dilation factor in x direction.
-   * @param dilationH The dilation factor in y direction.x
-   * @param appending If true, it will not initialize the output. Instead,
-   *                  it will append the results to the output.
+   * @param dilationH The dilation factor in y direction.
    */
-  template<typename MatType, typename CubeType>
-  static void Convolution(
-      const CubeType& input,
-      const MatType& filter,
-      CubeType& output,
-      const size_t dW = 1,
-      const size_t dH = 1,
-      const size_t dilationW = 1,
-      const size_t dilationH = 1,
-      const bool appending = false,
-      const typename std::enable_if_t<IsMatrix<MatType>::value>* = 0,
-      const typename std::enable_if_t<IsCube<CubeType>::value>* = 0)
+  template<typename MatType>
+  static void Conv2(const MatType& input,
+                    const MatType& filter,
+                    MatType& output,
+                    const size_t dW,
+                    const size_t dH,
+                    const size_t dilationW,
+                    const size_t dilationH,
+                    const std::enable_if_t<IsArma<MatType>::value>* = 0)
   {
-    MatType convOutput;
-    NaiveConvolution<BorderMode>::Convolution(input.slice(0), filter,
-        convOutput, dW, dH, dilationW, dilationH, appending);
+    using eT = typename MatType::elem_type;
 
-    if (!appending)
-      output = CubeType(convOutput.n_rows, convOutput.n_cols, input.n_slices);
+    // It seems to be about 3.5 times faster to use pointers instead of
+    // filter(ki, kj) * input(leftInput + ki, topInput + kj) and output(i, j).
+    eT* outputPtr = output.memptr();
+
+    for (size_t j = 0; j < output.n_cols; ++j)
+    {
+      for (size_t i = 0; i < output.n_rows; ++i, outputPtr++)
+      {
+        const eT* kernelPtr = filter.memptr();
+        for (size_t kj = 0; kj < filter.n_cols; ++kj)
+        {
+          const eT* inputPtr = input.colptr(kj * dilationH + j * dH) + i * dW;
+          for (size_t ki = 0; ki < filter.n_rows; ++ki, ++kernelPtr,
+              inputPtr += dilationW)
+            *outputPtr += *kernelPtr * (*inputPtr);
+        }
+      }
+    }
+  }
 
-    output.slice(0) = convOutput;
+#if defined(MLPACK_HAS_COOT)
 
-    for (size_t i = 1; i < input.n_slices; ++i)
+  /**
+   * Perform a valid convolution on Bandicoot matrices.
+   *
+   * @param input Input used to perform the convolution.
+   * @param filter Filter used to perform the convolution.
+   * @param output Output data that contains the results of the convolution.
+   * @param dW Stride of filter application in the x direction.
+   * @param dH Stride of filter application in the y direction.
+   * @param dilationW The dilation factor in x direction.
+   * @param dilationH The dilation factor in y direction.
+   */
+  template<typename MatType>
+  static void Conv2(const MatType& input,
+                    const MatType& filter,
+                    MatType& output,
+                    const size_t dW,
+                    const size_t dH,
+                    const size_t dilationW,
+                    const size_t dilationH,
+                    const std::enable_if_t<IsCoot<MatType>::value>* = 0)
+  {
+    bool useDilation = (dilationW != 1) || (dilationH != 1);
+    MatType dilatedFilter;
+    const size_t filterRows = filter.n_rows * dilationW - (dilationW - 1);
+    const size_t filterCols = filter.n_cols * dilationH - (dilationH - 1);
+    if (useDilation)
     {
-      NaiveConvolution<BorderMode>::Convolution(input.slice(i), filter,
-          output.slice(i), dW, dH, dilationW, dilationH, appending);
+      using UVecType = typename GetURowType<MatType>::type;
+      // Dilate the kernel by setting the non-zero rows and columns.
+      dilatedFilter.zeros(filterRows, filterCols);
+      dilatedFilter.submat(linspace<UVecType>(0, filterRows - 1, filter.n_rows),
+          linspace<UVecType>(0, filterCols - 1, filter.n_cols)) = filter;
+    }
+
+    // Apply convolution.
+    for (size_t j = 0; j < output.n_cols; ++j)
+    {
+      for (size_t i = 0; i < output.n_rows; ++i)
+      {
+        output.at(i, j) = accu((useDilation ? dilatedFilter : filter) %
+            input.submat(i * dW, j * dH, i * dW + filterRows - 1,
+                j * dH + filterCols - 1));
+      }
     }
   }
+#endif // defined(MLPACK_HAS_COOT)
 };  // class NaiveConvolution
 
 } // namespace mlpack