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

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

@@ -202,14 +202,14 @@ void BatchNormType<MatType>::Forward(
 
     // Input corresponds to output from previous layer.
     // Used a cube for simplicity.
-    arma::Cube<typename MatType::elem_type> inputTemp(
-        const_cast<MatType&>(input).memptr(), inputSize, size,
-        batchSize * higherDimension, false, false);
+    CubeType inputTemp;
+    MakeAlias(inputTemp, input, inputSize, size,
+        batchSize * higherDimension, 0, false);
 
     // Initialize output to same size and values for convenience.
-    arma::Cube<typename MatType::elem_type> outputTemp(
-        const_cast<MatType&>(output).memptr(), inputSize, size,
-        batchSize * higherDimension, false, false);
+    CubeType outputTemp;
+    MakeAlias(outputTemp, output, inputSize, size,
+        batchSize * higherDimension, 0, false);
     outputTemp = inputTemp;
 
     // Calculate mean and variance over all channels.
@@ -251,9 +251,9 @@ void BatchNormType<MatType>::Forward(
   {
     // Normalize the input and scale and shift the output.
     output = input;
-    arma::Cube<typename MatType::elem_type> outputTemp(
-        const_cast<MatType&>(output).memptr(), inputSize, size,
-        batchSize * higherDimension, false, false);
+    CubeType outputTemp;
+    MakeAlias(outputTemp, output, inputSize, size,
+        batchSize * higherDimension, 0, false);
 
     outputTemp.each_slice() -= repmat(runningMean.t(), inputSize, 1);
     outputTemp.each_slice() /= sqrt(repmat(runningVariance.t(),
@@ -276,16 +276,15 @@ void BatchNormType<MatType>::Backward(
   const size_t inputSize = inputDimension;
   const size_t m = inputSize * batchSize * higherDimension;
 
-  arma::Cube<typename MatType::elem_type> gyTemp(
-      const_cast<MatType&>(gy).memptr(), inputSize, size,
-      batchSize * higherDimension, false, false);
-  arma::Cube<typename MatType::elem_type> gTemp(
-      const_cast<MatType&>(g).memptr(), inputSize, size,
-      batchSize * higherDimension, false, false);
+  CubeType gyTemp;
+  MakeAlias(gyTemp, gy, inputSize, size,
+      batchSize * higherDimension, 0, false);
+  CubeType gTemp;
+  MakeAlias(gTemp, g, inputSize, size,
+      batchSize * higherDimension, 0, false);
 
   // Step 1: dl / dxhat.
-  arma::Cube<typename MatType::elem_type> norm =
-      gyTemp.each_slice() % repmat(gamma.t(), inputSize, 1);
+  CubeType norm = gyTemp.each_slice() % repmat(gamma.t(), inputSize, 1);
 
   // Step 2: sum dl / dxhat * (x - mu) * -0.5 * stdInv^3.
   MatType temp = sum(sum(norm % inputMean, 2), 0);
@@ -313,9 +312,9 @@ void BatchNormType<MatType>::Gradient(
 {
   const size_t inputSize = inputDimension;
 
-  arma::Cube<typename MatType::elem_type> errorTemp(
-      const_cast<MatType&>(error).memptr(), inputSize, size,
-      error.n_cols * higherDimension, false, false);
+  CubeType errorTemp;
+  MakeAlias(errorTemp, error, inputSize, size,
+      error.n_cols * higherDimension, 0, false);
 
   // Step 5: dl / dy * xhat.
   MatType temp = sum(sum(normalized % errorTemp, 0), 2);

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

@@ -34,6 +34,7 @@ template <typename MatType = arma::mat>
 class ConcatType : public MultiLayer<MatType>
 {
  public:
+  using CubeType = typename GetCubeType<MatType>::type;
   /**
    * Create the Concat object.  The axis used for concatenation will be the last
    * one.

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

@@ -119,15 +119,14 @@ void ConcatType<MatType>::Forward(const MatType& input, MatType& output)
   for (size_t i = axis + 1; i < this->outputDimensions.size(); ++i)
     slices *= this->outputDimensions[i];
 
-  std::vector<arma::Cube<typename MatType::elem_type>> layerOutputAliases(
-      this->layerOutputs.size());
+  std::vector<CubeType> layerOutputAliases(this->layerOutputs.size());
   for (size_t i = 0; i < this->layerOutputs.size(); ++i)
   {
     MakeAlias(layerOutputAliases[i], this->layerOutputs[i], rows,
         this->network[i]->OutputDimensions()[axis], slices);
   }
 
-  arma::Cube<typename MatType::elem_type> outputAlias;
+  CubeType outputAlias;
   MakeAlias(outputAlias, output, rows, this->outputDimensions[axis], slices);
 
   // Now get the columns from each output.
@@ -163,7 +162,7 @@ void ConcatType<MatType>::Backward(
   for (size_t i = axis + 1; i < this->outputDimensions.size(); ++i)
     slices *= this->outputDimensions[i];
 
-  arma::Cube<typename MatType::elem_type> gyTmp;
+  CubeType gyTmp;
   MakeAlias(gyTmp, gy, rows, this->outputDimensions[axis], slices);
 
   size_t startCol = 0;
@@ -209,7 +208,7 @@ void ConcatType<MatType>::Backward(
   for (size_t i = axis + 1; i < this->outputDimensions.size(); ++i)
     slices *= this->outputDimensions[i];
 
-  arma::Cube<typename MatType::elem_type> gyTmp;
+  CubeType gyTmp;
   MakeAlias(gyTmp, gy, rows, this->outputDimensions[axis], slices);
 
   size_t startCol = 0;
@@ -243,7 +242,7 @@ void ConcatType<MatType>::Gradient(
   for (size_t i = axis + 1; i < this->outputDimensions.size(); ++i)
     slices *= this->outputDimensions[i];
 
-  arma::Cube<typename MatType::elem_type> errorTmp;
+  CubeType errorTmp;
   MakeAlias(errorTmp, error, rows, this->outputDimensions[axis], slices);
 
   size_t startCol = 0;
@@ -282,7 +281,7 @@ void ConcatType<MatType>::Gradient(
   for (size_t i = axis + 1; i < this->outputDimensions.size(); ++i)
     slices *= this->outputDimensions[i];
 
-  arma::Cube<typename MatType::elem_type> errorTmp;
+  CubeType errorTmp;
   MakeAlias(errorTmp, error, rows, this->outputDimensions[axis], slices);
 
   size_t startCol = 0;

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

@@ -500,9 +500,9 @@ void ConvolutionType<
   const size_t paddedRows = this->inputDimensions[0] + padWLeft + padWRight;
   const size_t paddedCols = this->inputDimensions[1] + padHTop + padHBottom;
 
-  CubeType inputTemp(
-      const_cast<MatType&>(usingPadding ? inputPadded : input).memptr(),
-      paddedRows, paddedCols, inMaps * batchSize, false, false);
+  CubeType inputTemp;
+  MakeAlias(inputTemp, (usingPadding ? inputPadded : input),
+      paddedRows, paddedCols, inMaps * batchSize, 0, false);
 
   MatType temp(apparentWidth * apparentHeight * inMaps * higherInDimensions,
       batchSize);

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

@@ -527,9 +527,9 @@ void GroupedConvolutionType<
   const size_t paddedRows = this->inputDimensions[0] + padWLeft + padWRight;
   const size_t paddedCols = this->inputDimensions[1] + padHTop + padHBottom;
 
-  CubeType inputTemp(
-      const_cast<MatType&>(usingPadding ? inputPadded : input).memptr(),
-      paddedRows, paddedCols, inMaps * batchSize, false, false);
+  CubeType inputTemp;
+  MakeAlias(inputTemp, (usingPadding ? inputPadded : input),
+      paddedRows, paddedCols, inMaps * batchSize, 0, false);
 
   MatType temp(apparentWidth * apparentHeight * inMaps * higherInDimensions,
       batchSize);

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

@@ -37,6 +37,7 @@ template<
 class Linear3DType : public Layer<MatType>
 {
  public:
+  using CubeType = typename GetCubeType<MatType>::type;
   //! Create the Linear3D object.
   Linear3DType();
 

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

@@ -98,13 +98,12 @@ template<typename MatType, typename RegularizerType>
 void Linear3DType<MatType, RegularizerType>::Forward(
     const MatType& input, MatType& output)
 {
-  using CubeType = arma::Cube<typename MatType::elem_type>;
-
   const size_t nPoints = input.n_rows / this->inputDimensions[0];
   const size_t batchSize = input.n_cols;
 
-  const CubeType inputTemp(const_cast<MatType&>(input).memptr(),
-      this->inputDimensions[0], nPoints, batchSize, false, false);
+  const CubeType inputTemp;
+  MakeAlias(const_cast<CubeType&>(inputTemp), input, this->inputDimensions[0],
+      nPoints, batchSize, 0, false);
 
   for (size_t i = 0; i < batchSize; ++i)
   {
@@ -123,8 +122,6 @@ void Linear3DType<MatType, RegularizerType>::Backward(
     const MatType& gy,
     MatType& g)
 {
-  using CubeType = arma::Cube<typename MatType::elem_type>;
-
   if (gy.n_rows % outSize != 0)
   {
     Log::Fatal << "Number of rows in propagated error must be divisible by "
@@ -134,8 +131,9 @@ void Linear3DType<MatType, RegularizerType>::Backward(
   const size_t nPoints = gy.n_rows / outSize;
   const size_t batchSize = gy.n_cols;
 
-  const CubeType gyTemp(const_cast<MatType&>(gy).memptr(), outSize,
-      nPoints, batchSize, false, false);
+  const CubeType gyTemp;
+  MakeAlias(const_cast<CubeType&>(gyTemp), gy, outSize, nPoints, batchSize,
+      0, false);
 
   for (size_t i = 0; i < gyTemp.n_slices; ++i)
   {
@@ -151,18 +149,17 @@ void Linear3DType<MatType, RegularizerType>::Gradient(
     const MatType& error,
     MatType& gradient)
 {
-  using CubeType = arma::Cube<typename MatType::elem_type>;
-
   if (error.n_rows % outSize != 0)
     Log::Fatal << "Propagated error matrix has invalid dimension!" << std::endl;
 
   const size_t nPoints = input.n_rows / this->inputDimensions[0];
   const size_t batchSize = input.n_cols;
 
-  const CubeType inputTemp(const_cast<MatType&>(input).memptr(),
-      this->inputDimensions[0], nPoints, batchSize, false, false);
-  const CubeType errorTemp(const_cast<MatType&>(error).memptr(), outSize,
-      nPoints, batchSize, false, false);
+  const CubeType inputTemp, errorTemp;
+  MakeAlias(const_cast<CubeType&>(inputTemp), input, this->inputDimensions[0],
+      nPoints, batchSize, 0, false);
+  MakeAlias(const_cast<CubeType&>(errorTemp), error, outSize, nPoints,
+      batchSize, 0, false);
 
   CubeType dW(outSize, this->inputDimensions[0], batchSize);
   for (size_t i = 0; i < batchSize; ++i)

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

@@ -59,6 +59,7 @@ template<typename MatType = arma::mat>
 class MaxPoolingType : public Layer<MatType>
 {
  public:
+  using CubeType = typename GetCubeType<MatType>::type;
   //! Create the MaxPooling object.
   MaxPoolingType();
 
@@ -160,8 +161,8 @@ class MaxPoolingType : public Layer<MatType>
    * @param poolingIndices The pooled indices.
    */
   void PoolingOperation(
-      const arma::Cube<typename MatType::elem_type>& input,
-      arma::Cube<typename MatType::elem_type>& output,
+      const CubeType& input,
+      CubeType& output,
       arma::Cube<size_t>& poolingIndices)
   {
     // Iterate over all slices individually.
@@ -222,8 +223,8 @@ class MaxPoolingType : public Layer<MatType>
    * @param output The pooled result.
    */
   void PoolingOperation(
-      const arma::Cube<typename MatType::elem_type>& input,
-      arma::Cube<typename MatType::elem_type>& output)
+      const CubeType& input,
+      CubeType& output)
   {
     // Iterate over all slices individually.
     #pragma omp parallel for

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

@@ -114,13 +114,14 @@ MaxPoolingType<MatType>::operator=(MaxPoolingType&& other)
 template<typename MatType>
 void MaxPoolingType<MatType>::Forward(const MatType& input, MatType& output)
 {
-  arma::Cube<typename MatType::elem_type> inputTemp(
-      const_cast<MatType&>(input).memptr(), this->inputDimensions[0],
-      this->inputDimensions[1], input.n_cols * channels, false, false);
+  using CubeType = typename GetCubeType<MatType>::type;
+  CubeType inputTemp;
+  MakeAlias(inputTemp, input, this->inputDimensions[0],
+      this->inputDimensions[1], input.n_cols * channels, 0, false);
 
-  arma::Cube<typename MatType::elem_type> outputTemp(output.memptr(),
-      this->outputDimensions[0], this->outputDimensions[1],
-      input.n_cols * channels, false, true);
+  CubeType outputTemp;
+  MakeAlias(outputTemp, output, this->outputDimensions[0],
+      this->outputDimensions[1], input.n_cols * channels, 0, true);
 
   if (this->training)
   {
@@ -144,14 +145,14 @@ void MaxPoolingType<MatType>::Backward(
     const MatType& gy,
     MatType& g)
 {
-  arma::Cube<typename MatType::elem_type> mappedError =
-      arma::Cube<typename MatType::elem_type>(((MatType&) gy).memptr(),
-      this->outputDimensions[0], this->outputDimensions[1],
-      channels * input.n_cols, false, false);
-
-  arma::Cube<typename MatType::elem_type> gTemp(g.memptr(),
-      this->inputDimensions[0], this->inputDimensions[1],
-      channels * input.n_cols, false, true);
+  using CubeType = typename GetCubeType<MatType>::type;
+  CubeType mappedError;
+  MakeAlias(mappedError, gy, this->outputDimensions[0],
+      this->outputDimensions[1], channels * input.n_cols, 0, false);
+
+  CubeType gTemp;
+  MakeAlias(gTemp, g, this->inputDimensions[0], this->inputDimensions[1],
+      channels * input.n_cols, 0, true);
 
   gTemp.zeros();
 

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

@@ -29,6 +29,7 @@ template <typename MatType = arma::mat>
 class MeanPoolingType : public Layer<MatType>
 {
  public:
+  using CubeType = typename GetCubeType<MatType>::type;
   //! Create the MeanPoolingType object.
   MeanPoolingType();
 
@@ -129,8 +130,8 @@ class MeanPoolingType : public Layer<MatType>
    * @param output The pooled result.
    */
   void PoolingOperation(
-      const arma::Cube<typename MatType::elem_type>& input,
-      arma::Cube<typename MatType::elem_type>& output);
+      const CubeType& input,
+      CubeType& output);
 
   /**
    * Apply unpooling to the input and store the results.

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

@@ -113,14 +113,14 @@ void MeanPoolingType<MatType>::Forward(
     const MatType& input, MatType& output)
 {
   // Create Alias of input as 2D image as input is 1D vector.
-  arma::Cube<typename MatType::elem_type> inputTemp(
-      const_cast<MatType&>(input).memptr(), this->inputDimensions[0],
-      this->inputDimensions[1], input.n_cols * channels, false, false);
+  CubeType inputTemp;
+  MakeAlias(inputTemp, input, this->inputDimensions[0],
+      this->inputDimensions[1], input.n_cols * channels, 0, false);
 
   // Create Alias of output as 2D image as output is 1D vector.
-  arma::Cube<typename MatType::elem_type> outputTemp(output.memptr(),
-      this->outputDimensions[0], this->outputDimensions[1],
-      input.n_cols * channels, false, true);
+  CubeType outputTemp;
+  MakeAlias(outputTemp, output, this->outputDimensions[0],
+      this->outputDimensions[1], input.n_cols * channels, 0, true);
 
   // Apply Pooling to the input.
   PoolingOperation(inputTemp, outputTemp);
@@ -134,15 +134,14 @@ void MeanPoolingType<MatType>::Backward(
   MatType& g)
 {
   // Create Alias of gy as 2D matrix as gy is 1D vector.
-  arma::Cube<typename MatType::elem_type> mappedError =
-      arma::Cube<typename MatType::elem_type>(((MatType&) gy).memptr(),
-      this->outputDimensions[0], this->outputDimensions[1],
-      channels * input.n_cols, false, false);
+  CubeType mappedError;
+  MakeAlias(mappedError, gy, this->outputDimensions[0],
+      this->outputDimensions[1], channels * input.n_cols, 0, false);
 
   // Create Alias of g as 2D matrix as g is 1D vector.
-  arma::Cube<typename MatType::elem_type> gTemp(g.memptr(),
-      this->inputDimensions[0], this->inputDimensions[1],
-      channels * input.n_cols, false, true);
+  CubeType gTemp;
+  MakeAlias(gTemp, g, this->inputDimensions[0],
+      this->inputDimensions[1], channels * input.n_cols, 0, true);
 
   // Initialize the gradient with zero.
   gTemp.zeros();
@@ -201,8 +200,8 @@ void MeanPoolingType<MatType>::serialize(
 
 template<typename MatType>
 void MeanPoolingType<MatType>::PoolingOperation(
-    const arma::Cube<typename MatType::elem_type>& input,
-    arma::Cube<typename MatType::elem_type>& output)
+    const CubeType& input,
+    CubeType& output)
 {
   // Iterate over all slices individually.
   #pragma omp parallel for

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

@@ -69,6 +69,7 @@ template <
 class MultiheadAttentionType : public Layer<MatType>
 {
  public:
+  using CubeType = typename GetCubeType<MatType>::type;
   /**
    * Default constructor.
    */
@@ -321,19 +322,19 @@ class MultiheadAttentionType : public Layer<MatType>
   MatType weights;
 
   //! Locally-stored projected query matrix over linear layer.
-  arma::Cube<ElemType> qProj;
+  CubeType qProj;
 
   //! Locally-stored projected key matrix over linear layer.
-  arma::Cube<ElemType> kProj;
+  CubeType kProj;
 
   //! Locally-stored projected value matrix over linear layer.
-  arma::Cube<ElemType> vProj;
+  CubeType vProj;
 
   //! Locally-stored result of output of dropout layer.
-  arma::Cube<ElemType> scores;
+  CubeType scores;
 
   //! Locally-stored attention output weight to be fed to last linear layer.
-  arma::Cube<ElemType> attnOut;
+  CubeType attnOut;
 
   //! Softmax layer to represent the probabilities of next sequence.
   SoftmaxType<MatType> softmax;

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

@@ -73,8 +73,6 @@ template <typename MatType, typename RegularizerType>
 void MultiheadAttentionType<MatType, RegularizerType>::
 Forward(const MatType& input, MatType& output)
 {
-  using CubeType = arma::Cube<typename MatType::elem_type>;
-
   if (input.n_rows != embedDim *
       (selfAttention ? srcSeqLen : (tgtSeqLen + 2 * srcSeqLen)))
   {
@@ -97,14 +95,14 @@ Forward(const MatType& input, MatType& output)
   // The shape of q : (embedDim, tgtSeqLen, batchSize).
   // The shape of k : (embedDim, srcSeqLen, batchSize).
   // The shape of v : (embedDim, srcSeqLen, batchSize).
-  const CubeType q(const_cast<MatType&>(input).memptr(),
-      embedDim, tgtSeqLen, batchSize, false, false);
-  const CubeType k(const_cast<MatType&>(input).memptr() +
-      (selfAttention ? 0 : embedDim * tgtSeqLen * batchSize),
-      embedDim, srcSeqLen, batchSize, false, false);
-  const CubeType v(const_cast<MatType&>(input).memptr() +
+  const CubeType q, k, v;
+  MakeAlias(const_cast<CubeType&>(q), input, embedDim, tgtSeqLen, batchSize,
+      0, false);
+  MakeAlias(const_cast<CubeType&>(k), input, embedDim, srcSeqLen, batchSize,
+      (selfAttention ? 0 : embedDim * tgtSeqLen * batchSize), false);
+  MakeAlias(const_cast<CubeType&>(v), input, embedDim, srcSeqLen, batchSize,
       (selfAttention ? 0 : embedDim * (tgtSeqLen + srcSeqLen) * batchSize),
-      embedDim, srcSeqLen, batchSize, false, false);
+      false);
 
   // qProj, kProj, and vProj are the linearly projected query, key and value
   // respectively.
@@ -187,8 +185,6 @@ Backward(const MatType& /* input */,
          const MatType& gy,
          MatType& g)
 {
-  using CubeType = arma::Cube<typename MatType::elem_type>;
-
   if (gy.n_rows != tgtSeqLen * embedDim)
   {
     Log::Fatal << "Backpropagated error has incorrect dimensions!" << std::endl;
@@ -202,8 +198,11 @@ Backward(const MatType& /* input */,
   // The shape of gyTemp : (tgtSeqLen, embedDim, batchSize).
   // We need not split it into n heads now because this is the part when
   // output were concatenated from n heads.
-  CubeType gyTemp(const_cast<MatType&>(gy).memptr(), embedDim,
-      tgtSeqLen, batchSize, true, false);
+  const CubeType gyTempAlias;
+  MakeAlias(const_cast<CubeType&>(gyTempAlias), gy, embedDim, tgtSeqLen,
+      batchSize, 0, false);
+  // Make a copy of the alias so gy actually remains constant
+  CubeType gyTemp = gyTempAlias;
 
   // The shape of gyTemp : (embedDim, tgtSeqLen, batchSize).
   // The shape of outWt : (embedDim, embedDim).
@@ -306,8 +305,6 @@ Gradient(const MatType& input,
          const MatType& error,
          MatType& gradient)
 {
-  using CubeType = arma::Cube<typename MatType::elem_type>;
-
   if (input.n_rows != embedDim * (selfAttention ? srcSeqLen :
       (tgtSeqLen + 2 * srcSeqLen)))
   {
@@ -332,19 +329,21 @@ Gradient(const MatType& input,
   // The shape of gradient : (4 * embedDim * embedDim + 4 * embedDim, 1).
   gradient.set_size(arma::size(weights));
 
-  const CubeType q(const_cast<MatType&>(input).memptr(),
-      embedDim, tgtSeqLen, batchSize, false, false);
-  const CubeType k(const_cast<MatType&>(input).memptr() +
-      (selfAttention ? 0 : q.n_elem), embedDim, srcSeqLen, batchSize, false,
-      false);
-  const CubeType v(const_cast<MatType&>(input).memptr() +
-      (selfAttention ? 0 : (q.n_elem + k.n_elem)), embedDim, srcSeqLen,
-      batchSize, false, false);
+  const CubeType q, k, v;
+  MakeAlias(const_cast<CubeType&>(q), input, embedDim, tgtSeqLen, batchSize,
+      0, false);
+  MakeAlias(const_cast<CubeType&>(k), input, embedDim, srcSeqLen, batchSize,
+      (selfAttention ? 0 : q.n_elem), false);
+  MakeAlias(const_cast<CubeType&>(v), input, embedDim, srcSeqLen, batchSize,
+      (selfAttention ? 0 : (q.n_elem + k.n_elem)), false);
 
   // Reshape the propagated error into a cube.
   // The shape of errorTemp : (embedDim, tgtSeqLen, batchSize).
-  CubeType errorTemp(const_cast<MatType&>(error).memptr(), embedDim,
-      tgtSeqLen, batchSize, true, false);
+  const CubeType errorTempAlias;
+  MakeAlias(const_cast<CubeType&>(errorTempAlias), error, embedDim, tgtSeqLen,
+      batchSize, 0, false);
+  // Make a copy of the alias so error actually remains constant
+  CubeType errorTemp = errorTempAlias;
 
   // Gradient wrt. outBias, i.e. dL/d(outBias).
   gradient.rows(4 * wtSize + 3 * embedDim, 4 * wtSize + 4 * embedDim - 1)

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

@@ -32,6 +32,7 @@ template<typename MatType = arma::mat>
 class NearestInterpolationType : public Layer<MatType>
 {
  public:
+  using CubeType = typename GetCubeType<MatType>::type;
   //! Create the NearestInterpolation object.
   NearestInterpolationType();
 

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

@@ -92,8 +92,8 @@ void NearestInterpolationType<MatType>::Forward(
   const size_t inRowSize = this->inputDimensions[0];
   const size_t inColSize = this->inputDimensions[1];
 
-  arma::cube inputAsCube;
-  arma::cube outputAsCube;
+  CubeType inputAsCube;
+  CubeType outputAsCube;
 
   MakeAlias(inputAsCube, input, inRowSize, inColSize, channels, 0, false);
   MakeAlias(outputAsCube, output, outRowSize, outColSize, channels, 0, true);
@@ -126,8 +126,8 @@ void NearestInterpolationType<MatType>::Backward(
   const size_t inRowSize = this->inputDimensions[0];
   const size_t inColSize = this->inputDimensions[1];
 
-  arma::cube outputAsCube;
-  arma::cube gradientAsCube;
+  CubeType outputAsCube;
+  CubeType gradientAsCube;
 
   MakeAlias(outputAsCube, output, inRowSize, inColSize, channels, 0, true);
   MakeAlias(gradientAsCube, gradient, outRowSize, outColSize, channels, 0,

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

@@ -28,6 +28,7 @@ template<typename MatType = arma::mat>
 class PaddingType : public Layer<MatType>
 {
  public:
+  using CubeType = typename GetCubeType<MatType>::type;
   /**
    * Create the Padding object using the specified number of output units.
    *

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

@@ -97,13 +97,12 @@ void PaddingType<MatType>::Forward(const MatType& input, MatType& output)
 {
   // Make an alias of the input and output so that we can deal with the first
   // two dimensions directly.
-  arma::Cube<typename MatType::elem_type> reshapedInput(
-      (typename MatType::elem_type*) input.memptr(),
-      this->inputDimensions[0], this->inputDimensions[1], totalInMaps *
-      input.n_cols, false, true);
-  arma::Cube<typename MatType::elem_type> reshapedOutput(output.memptr(),
-      this->outputDimensions[0], this->outputDimensions[1], totalInMaps *
-      output.n_cols, false, true);
+  CubeType reshapedInput;
+  MakeAlias(reshapedInput, input, this->inputDimensions[0],
+      this->inputDimensions[1], totalInMaps * input.n_cols, 0, true);
+  CubeType reshapedOutput;
+  MakeAlias(reshapedOutput, output, this->outputDimensions[0],
+      this->outputDimensions[1], totalInMaps * output.n_cols, 0, true);
 
   // Set the padding parts to 0.
   if (padHTop > 0)
@@ -154,12 +153,12 @@ void PaddingType<MatType>::Backward(
 {
   // Reshape g and gy so that extracting the un-padded input is easier to
   // understand.
-  arma::Cube<typename MatType::elem_type> reshapedGy(
-      (typename MatType::elem_type*) gy.memptr(), this->outputDimensions[0],
-      this->outputDimensions[1], totalInMaps * gy.n_cols, false, true);
-  arma::Cube<typename MatType::elem_type> reshapedG(g.memptr(),
-      this->inputDimensions[0], this->inputDimensions[1], totalInMaps *
-      g.n_cols, false, true);
+  CubeType reshapedGy;
+  MakeAlias(reshapedGy, gy, this->outputDimensions[0],
+      this->outputDimensions[1], totalInMaps * gy.n_cols, 0, true);
+  CubeType reshapedG;
+  MakeAlias(reshapedG, g, this->inputDimensions[0],
+      this->inputDimensions[1], totalInMaps * g.n_cols, 0, true);
 
   reshapedG = reshapedGy.tube(padWLeft,
                               padHTop,

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

@@ -58,6 +58,7 @@ template<typename MatType = arma::mat>
 class RecurrentLayer : public Layer<MatType>
 {
  public:
+  using CubeType = typename GetCubeType<MatType>::type;
   /**
    * Create the RecurrentLayer.
    */
@@ -152,10 +153,10 @@ class RecurrentLayer : public Layer<MatType>
   // This holds the recurrent state at each time step for BPTT.  If BPTT is not
   // being used (e.g. if we are only running the network in forward mode and not
   // training), then only one previous time step is held.
-  arma::Cube<typename MatType::elem_type> recurrentState;
+  CubeType recurrentState;
   // This holds the recurrent gradient for BPTT.  If BPTT is not being used,
   // this is empty.
-  arma::Cube<typename MatType::elem_type> recurrentGradient;
+  CubeType recurrentGradient;
 };
 
 } // namespace mlpack

mlpack/include/mlpack/methods/ann/loss_functions/cosine_embedding_loss_impl.hpp

@@ -67,6 +67,7 @@ void CosineEmbeddingLossType<MatType>::Backward(
     const MatType& target,
     MatType& loss)
 {
+  using ColType = typename GetColType<MatType>::type;
   using ElemType = typename MatType::elem_type;
 
   const size_t cols = prediction.n_cols;
@@ -74,12 +75,12 @@ void CosineEmbeddingLossType<MatType>::Backward(
   if (arma::size(prediction) != arma::size(target))
     Log::Fatal << "Input Tensors must have same dimensions." << std::endl;
 
-  arma::Col<ElemType> inputTemp1 = vectorise(prediction);
-  arma::Col<ElemType> inputTemp2 = vectorise(target);
+  ColType inputTemp1 = vectorise(prediction);
+  ColType inputTemp2 = vectorise(target);
   loss.set_size(arma::size(inputTemp1));
 
-  arma::Col<ElemType> outputTemp(loss.memptr(), inputTemp1.n_elem,
-      false, false);
+  ColType outputTemp;
+  MakeAlias(outputTemp, loss, inputTemp1.n_elem, 0, false);
   for (size_t i = 0; i < inputTemp1.n_elem; i += cols)
   {
     const ElemType cosDist = CosineDistance::Evaluate(inputTemp1(