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

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

@@ -19,8 +19,8 @@
 namespace mlpack {
 
 template<typename MatType>
-ConcatenateType<MatType>::
-ConcatenateType(const MatType& concat) :
+Concatenate<MatType>::
+Concatenate(const MatType& concat) :
     Layer<MatType>(),
     concat(concat)
 {
@@ -28,8 +28,8 @@ ConcatenateType(const MatType& concat) :
 }
 
 template<typename MatType>
-ConcatenateType<MatType>::
-ConcatenateType(const ConcatenateType& other) :
+Concatenate<MatType>::
+Concatenate(const Concatenate& other) :
     Layer<MatType>(other),
     concat(other.concat)
 {
@@ -37,8 +37,8 @@ ConcatenateType(const ConcatenateType& other) :
 }
 
 template<typename MatType>
-ConcatenateType<MatType>::
-ConcatenateType(ConcatenateType&& other) :
+Concatenate<MatType>::
+Concatenate(Concatenate&& other) :
     Layer<MatType>(std::move(other)),
     concat(other.concat)
 {
@@ -46,8 +46,8 @@ ConcatenateType(ConcatenateType&& other) :
 }
 
 template<typename MatType>
-ConcatenateType<MatType>&
-ConcatenateType<MatType>::operator=(const ConcatenateType& other)
+Concatenate<MatType>&
+Concatenate<MatType>::operator=(const Concatenate& other)
 {
   if (&other != this)
   {
@@ -59,8 +59,8 @@ ConcatenateType<MatType>::operator=(const ConcatenateType& other)
 }
 
 template<typename MatType>
-ConcatenateType<MatType>&
-ConcatenateType<MatType>::operator=(ConcatenateType&& other)
+Concatenate<MatType>&
+Concatenate<MatType>::operator=(Concatenate&& other)
 {
   if (&other != this)
   {
@@ -72,7 +72,7 @@ ConcatenateType<MatType>::operator=(ConcatenateType&& other)
 }
 
 template<typename MatType>
-void ConcatenateType<MatType>::Forward(const MatType& input, MatType& output)
+void Concatenate<MatType>::Forward(const MatType& input, MatType& output)
 {
   if (concat.is_empty())
   {
@@ -86,7 +86,7 @@ void ConcatenateType<MatType>::Forward(const MatType& input, MatType& output)
 }
 
 template<typename MatType>
-void ConcatenateType<MatType>::Backward(
+void Concatenate<MatType>::Backward(
     const MatType& /* input */,
     const MatType& /* output */,
     const MatType& gy,
@@ -97,7 +97,7 @@ void ConcatenateType<MatType>::Backward(
 }
 
 template<typename MatType>
-void ConcatenateType<MatType>::ComputeOutputDimensions()
+void Concatenate<MatType>::ComputeOutputDimensions()
 {
   // This flattens the input.
   size_t inSize = this->inputDimensions[0];
@@ -114,7 +114,7 @@ void ConcatenateType<MatType>::ComputeOutputDimensions()
  */
 template<typename MatType>
 template<typename Archive>
-void ConcatenateType<MatType>::serialize(
+void Concatenate<MatType>::serialize(
   Archive& ar, const uint32_t /* version */)
 {
   ar(cereal::base_class<Layer<MatType>>(this));

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

@@ -16,8 +16,7 @@
 
 #include <mlpack/methods/ann/convolution_rules/border_modes.hpp>
 #include <mlpack/methods/ann/convolution_rules/naive_convolution.hpp>
-#include <mlpack/methods/ann/convolution_rules/fft_convolution.hpp>
-#include <mlpack/methods/ann/convolution_rules/svd_convolution.hpp>
+#include <mlpack/methods/ann/convolution_rules/im2col_convolution.hpp>
 #include <mlpack/core/util/to_lower.hpp>
 
 #include "layer.hpp"
@@ -65,21 +64,23 @@ namespace mlpack {
  *    computation.
  */
 template <
-    typename ForwardConvolutionRule = NaiveConvolution<ValidConvolution>,
-    typename BackwardConvolutionRule = NaiveConvolution<FullConvolution>,
-    typename GradientConvolutionRule = NaiveConvolution<ValidConvolution>,
-    typename MatType = arma::mat
+    typename MatType = arma::mat,
+    typename ForwardConvolutionRule = Im2ColConvolution<ValidConvolution>,
+    typename BackwardConvolutionRule = Im2ColConvolution<FullConvolution>,
+    typename GradientConvolutionRule = Im2ColConvolution<ValidConvolution>
 >
-class ConvolutionType : public Layer<MatType>
+class Convolution : public Layer<MatType>
 {
  public:
+  // Convenience typedefs for element types and reshaping data into cubes.
+  using ElemType = typename MatType::elem_type;
   using CubeType = typename GetCubeType<MatType>::type;
 
-  //! Create the ConvolutionType object.
-  ConvolutionType();
+  // Create the Convolution object.
+  Convolution();
 
   /**
-   * Create the ConvolutionType object using the specified number of output
+   * Create the Convolution object using the specified number of output
    * maps, filter size, stride and padding parameter.
    *
    * @param maps The number of output maps.
@@ -94,15 +95,15 @@ class ConvolutionType : public Layer<MatType>
    *    will be used.
    * @param useBias Whether or not to use a bias with the convolution.
    */
-  ConvolutionType(const size_t maps,
-                  const size_t kernelWidth,
-                  const size_t kernelHeight,
-                  const size_t strideWidth = 1,
-                  const size_t strideHeight = 1,
-                  const size_t padW = 0,
-                  const size_t padH = 0,
-                  const std::string& paddingType = "none",
-                  const bool useBias = true);
+  Convolution(const size_t maps,
+              const size_t kernelWidth,
+              const size_t kernelHeight,
+              const size_t strideWidth = 1,
+              const size_t strideHeight = 1,
+              const size_t padW = 0,
+              const size_t padH = 0,
+              const std::string& paddingType = "none",
+              const bool useBias = true);
 
   /**
    * Create the Convolution object using the specified number of input maps,
@@ -124,33 +125,33 @@ class ConvolutionType : public Layer<MatType>
    *      will be used.
    * @param useBias Whether or not to use a bias with the convolution.
    */
-  ConvolutionType(const size_t maps,
-                  const size_t kernelWidth,
-                  const size_t kernelHeight,
-                  const size_t strideWidth,
-                  const size_t strideHeight,
-                  const std::tuple<size_t, size_t>& padW,
-                  const std::tuple<size_t, size_t>& padH,
-                  const std::string& paddingType = "none",
-                  const bool useBias = true);
+  Convolution(const size_t maps,
+              const size_t kernelWidth,
+              const size_t kernelHeight,
+              const size_t strideWidth,
+              const size_t strideHeight,
+              const std::tuple<size_t, size_t>& padW,
+              const std::tuple<size_t, size_t>& padH,
+              const std::string& paddingType = "none",
+              const bool useBias = true);
 
-  //! Clone the ConvolutionType object. This handles polymorphism correctly.
-  ConvolutionType* Clone() const { return new ConvolutionType(*this); }
+  //! Clone the Convolution object. This handles polymorphism correctly.
+  Convolution* Clone() const { return new Convolution(*this); }
 
-  //! Copy the given ConvolutionType (but not weights).
-  ConvolutionType(const ConvolutionType& layer);
+  //! Copy the given Convolution (but not weights).
+  Convolution(const Convolution& layer);
 
-  //! Take ownership of the given ConvolutionType (but not weights).
-  ConvolutionType(ConvolutionType&&);
+  //! Take ownership of the given Convolution (but not weights).
+  Convolution(Convolution&&);
 
-  //! Copy the given ConvolutionType (but not weights).
-  ConvolutionType& operator=(const ConvolutionType& layer);
+  //! Copy the given Convolution (but not weights).
+  Convolution& operator=(const Convolution& layer);
 
-  //! Take ownership of the given ConvolutionType (but not weights).
-  ConvolutionType& operator=(ConvolutionType&& layer);
+  //! Take ownership of the given Convolution (but not weights).
+  Convolution& operator=(Convolution&& layer);
 
   // Virtual destructor.
-  virtual ~ConvolutionType() { }
+  virtual ~Convolution() { }
 
   /*
    * Set the weight and bias term.
@@ -376,10 +377,10 @@ class ConvolutionType : public Layer<MatType>
   CubeType gradientTemp;
 
   //! Locally-stored padding layer.
-  PaddingType<MatType> padding;
+  Padding<MatType> padding;
 
   //! Locally-stored padding layer for backward pass.
-  PaddingType<MatType> paddingBackward;
+  Padding<MatType> paddingBackward;
 
   //! Type of padding.
   std::string paddingType;
@@ -396,12 +397,6 @@ class ConvolutionType : public Layer<MatType>
   size_t apparentHeight;
 }; // class Convolution
 
-// Standard Convolution layer.
-using Convolution = ConvolutionType<NaiveConvolution<ValidConvolution>,
-                                    NaiveConvolution<FullConvolution>,
-                                    NaiveConvolution<ValidConvolution>,
-                                    arma::mat>;
-
 } // namespace mlpack
 
 // Include implementation.