Remove last references to arma::

akropp · akropp · commit 0253a8698b82 · 2024-01-09T17:07:51.000-05:00
diff --git a/src/mlpack/methods/ann/layer/repeat.hpp b/src/mlpack/methods/ann/layer/repeat.hpp
@@ -135,12 +135,11 @@ class RepeatType : public Layer<MatType>
 
   // Cache the target indices for a single tensor for use
   // in the forward pass.
-  arma::uvec outIdxs;
+  std::vector<size_t> outIdxs;
 
   // Cache the contributions of each output element to the
   // input elements for use in the backward pass.
   size_t sizeMult;
-  arma::umat backIdxs;
 }; // class RepeatType.
 
 // Standard Repeat layer.
diff --git a/src/mlpack/methods/ann/layer/repeat_impl.hpp b/src/mlpack/methods/ann/layer/repeat_impl.hpp
@@ -40,8 +40,7 @@ RepeatType<MatType>::RepeatType(const RepeatType& other) :
     multiples(other.multiples),
     interleave(other.interleave),
     outIdxs(other.outIdxs),
-    sizeMult(other.sizeMult),
-    backIdxs(other.backIdxs)
+    sizeMult(other.sizeMult)
 {
   // Nothing else to do.
 }
@@ -52,8 +51,7 @@ RepeatType<MatType>::RepeatType(RepeatType&& other)  noexcept :
     multiples(other.multiples),
     interleave(other.interleave),
     outIdxs(other.outIdxs),
-    sizeMult(other.sizeMult),
-    backIdxs(other.backIdxs)
+    sizeMult(other.sizeMult)
 {
   // Nothing else to do.
 }
@@ -68,7 +66,6 @@ RepeatType<MatType>& RepeatType<MatType>::operator=(const RepeatType& other)
     interleave = other.interleave;
     outIdxs = other.outIdxs;
     sizeMult = other.sizeMult;
-    backIdxs = other.backIdxs;
   }
 
   return *this;
@@ -84,7 +81,6 @@ RepeatType<MatType>& RepeatType<MatType>::operator=(RepeatType&& other) noexcept
     interleave = std::move(other.interleave);
     outIdxs = std::move(other.outIdxs);
     sizeMult = other.sizeMult;
-    backIdxs = other.backIdxs;
   }
 
   return *this;
@@ -106,7 +102,13 @@ void RepeatType<MatType>::ComputeOutputDimensions()
   {
     inputSize *= this->inputDimensions[i];
   }
-  arma::umat idxs = arma::regspace<arma::uvec>(0, inputSize - 1);
+  MatType idxs(inputSize, 1);
+  for (size_t i=0; i<inputSize; i++)
+  {
+    idxs.at(i) = i;
+  }
+  // want to do this, but can't leave it without a namespace (e.g. arma::)
+  //  MatType idxs = linspace<MatType>(0, inputSize - 1, inputSize);
 
   // Here, we are going to pre-compute the source index for each output
   // for a single tensor.  Since the tensors are flattened into 1-d
@@ -150,24 +152,24 @@ void RepeatType<MatType>::ComputeOutputDimensions()
     }
     outSize *= this->outputDimensions[i];
   }
-  outIdxs = idxs.as_col();
-
-  // Now, we are going to pre-compute the contribution of each output
-  // element to the input elements.  This will be used in the backward
-  // pass with a simple matrix multiplication.
-  backIdxs.set_size(inputSize, sizeMult);
-  arma::uvec counts(inputSize, arma::fill::zeros);
-  for (size_t i = 0; i < outIdxs.n_elem; i++)
+  outIdxs.resize(idxs.n_elem);
+  for (size_t i=0; i<idxs.n_elem; i++)
   {
-    auto r = outIdxs.at(i);
-    backIdxs.at(r, counts.at(r)++) = i;
+    outIdxs[i] = idxs.at(i);
   }
 }
 
 template<typename MatType>
 void RepeatType<MatType>::Forward(const MatType& input, MatType& output)
 {
-  output = input.rows(outIdxs);
+#pragma omp parallel for
+  for (size_t j=0; j<input.n_cols; j++)
+  {
+    for (size_t i = 0; i < outIdxs.size(); i++)
+    {
+      output.at(i, j) = input.at(outIdxs.at(i), j);
+    }
+  }
 }
 
 template<typename MatType>
@@ -177,12 +179,15 @@ void RepeatType<MatType>::Backward(
     const MatType& gy,
     MatType& g)
 {
-  g = gy.rows(backIdxs.col(0));
-  for (size_t c = 1; c < sizeMult; c++)
+#pragma omp parallel for
+  for (size_t j=0; j<gy.n_cols; j++)
   {
-    g += gy.rows(backIdxs.col(c));
+    g.col(j).zeros();
+    for (size_t i=0; i<outIdxs.size(); i++) {
+      g.at(outIdxs.at(i), j) += gy.at(i, j);
+    }
+    g.col(j) /= sizeMult;
   }
-  g /= sizeMult;
 }
 
 template<typename MatType>
@@ -196,7 +201,6 @@ void RepeatType<MatType>::serialize(
   ar(CEREAL_NVP(interleave));
   ar(CEREAL_NVP(outIdxs));
   ar(CEREAL_NVP(sizeMult));
-  ar(CEREAL_NVP(backIdxs));
 }
 
 } // namespace mlpack

Original file line number	Diff line number	Diff line change
`@@ -40,8 +40,7 @@ RepeatType<MatType>::RepeatType(const RepeatType& other) :`
`40`	`40`	`multiples(other.multiples),`
`41`	`41`	`interleave(other.interleave),`
`42`	`42`	`outIdxs(other.outIdxs),`
`43`		`- sizeMult(other.sizeMult),`
`44`		`- backIdxs(other.backIdxs)`
	`43`	`+ sizeMult(other.sizeMult)`
`45`	`44`	`{`
`46`	`45`	`// Nothing else to do.`
`47`	`46`	`}`
`@@ -52,8 +51,7 @@ RepeatType<MatType>::RepeatType(RepeatType&& other) noexcept :`
`52`	`51`	`multiples(other.multiples),`
`53`	`52`	`interleave(other.interleave),`
`54`	`53`	`outIdxs(other.outIdxs),`
`55`		`- sizeMult(other.sizeMult),`
`56`		`- backIdxs(other.backIdxs)`
	`54`	`+ sizeMult(other.sizeMult)`
`57`	`55`	`{`
`58`	`56`	`// Nothing else to do.`
`59`	`57`	`}`
`@@ -68,7 +66,6 @@ RepeatType<MatType>& RepeatType<MatType>::operator=(const RepeatType& other)`
`68`	`66`	`interleave = other.interleave;`
`69`	`67`	`outIdxs = other.outIdxs;`
`70`	`68`	`sizeMult = other.sizeMult;`
`71`		`- backIdxs = other.backIdxs;`
`72`	`69`	`}`
`73`	`70`
`74`	`71`	`return *this;`
`@@ -84,7 +81,6 @@ RepeatType<MatType>& RepeatType<MatType>::operator=(RepeatType&& other) noexcept`
`84`	`81`	`interleave = std::move(other.interleave);`
`85`	`82`	`outIdxs = std::move(other.outIdxs);`
`86`	`83`	`sizeMult = other.sizeMult;`
`87`		`- backIdxs = other.backIdxs;`
`88`	`84`	`}`
`89`	`85`
`90`	`86`	`return *this;`
`@@ -106,7 +102,13 @@ void RepeatType<MatType>::ComputeOutputDimensions()`
`106`	`102`	`{`
`107`	`103`	`inputSize *= this->inputDimensions[i];`
`108`	`104`	`}`
`109`		`- arma::umat idxs = arma::regspace<arma::uvec>(0, inputSize - 1);`
	`105`	`+ MatType idxs(inputSize, 1);`
	`106`	`+ for (size_t i=0; i<inputSize; i++)`
	`107`	`+ {`
	`108`	`+ idxs.at(i) = i;`
	`109`	`+ }`
	`110`	`+ // want to do this, but can't leave it without a namespace (e.g. arma::)`
	`111`	`+ // MatType idxs = linspace<MatType>(0, inputSize - 1, inputSize);`
`110`	`112`
`111`	`113`	`// Here, we are going to pre-compute the source index for each output`
`112`	`114`	`// for a single tensor. Since the tensors are flattened into 1-d`
`@@ -150,24 +152,24 @@ void RepeatType<MatType>::ComputeOutputDimensions()`
`150`	`152`	`}`
`151`	`153`	`outSize *= this->outputDimensions[i];`
`152`	`154`	`}`
`153`		`- outIdxs = idxs.as_col();`
`154`		`-`
`155`		`- // Now, we are going to pre-compute the contribution of each output`
`156`		`- // element to the input elements. This will be used in the backward`
`157`		`- // pass with a simple matrix multiplication.`
`158`		`- backIdxs.set_size(inputSize, sizeMult);`
`159`		`- arma::uvec counts(inputSize, arma::fill::zeros);`
`160`		`- for (size_t i = 0; i < outIdxs.n_elem; i++)`
	`155`	`+ outIdxs.resize(idxs.n_elem);`
	`156`	`+ for (size_t i=0; i<idxs.n_elem; i++)`
`161`	`157`	`{`
`162`		`- auto r = outIdxs.at(i);`
`163`		`- backIdxs.at(r, counts.at(r)++) = i;`
	`158`	`+ outIdxs[i] = idxs.at(i);`
`164`	`159`	`}`
`165`	`160`	`}`
`166`	`161`
`167`	`162`	`template<typename MatType>`
`168`	`163`	`void RepeatType<MatType>::Forward(const MatType& input, MatType& output)`
`169`	`164`	`{`
`170`		`- output = input.rows(outIdxs);`
	`165`	`+#pragma omp parallel for`
	`166`	`+ for (size_t j=0; j<input.n_cols; j++)`
	`167`	`+ {`
	`168`	`+ for (size_t i = 0; i < outIdxs.size(); i++)`
	`169`	`+ {`
	`170`	`+ output.at(i, j) = input.at(outIdxs.at(i), j);`
	`171`	`+ }`
	`172`	`+ }`
`171`	`173`	`}`
`172`	`174`
`173`	`175`	`template<typename MatType>`
`@@ -177,12 +179,15 @@ void RepeatType<MatType>::Backward(`
`177`	`179`	`const MatType& gy,`
`178`	`180`	`MatType& g)`
`179`	`181`	`{`
`180`		`- g = gy.rows(backIdxs.col(0));`
`181`		`- for (size_t c = 1; c < sizeMult; c++)`
	`182`	`+#pragma omp parallel for`
	`183`	`+ for (size_t j=0; j<gy.n_cols; j++)`
`182`	`184`	`{`
`183`		`- g += gy.rows(backIdxs.col(c));`
	`185`	`+ g.col(j).zeros();`
	`186`	`+ for (size_t i=0; i<outIdxs.size(); i++) {`
	`187`	`+ g.at(outIdxs.at(i), j) += gy.at(i, j);`
	`188`	`+ }`
	`189`	`+ g.col(j) /= sizeMult;`
`184`	`190`	`}`
`185`		`- g /= sizeMult;`
`186`	`191`	`}`
`187`	`192`
`188`	`193`	`template<typename MatType>`
`@@ -196,7 +201,6 @@ void RepeatType<MatType>::serialize(`
`196`	`201`	`ar(CEREAL_NVP(interleave));`
`197`	`202`	`ar(CEREAL_NVP(outIdxs));`
`198`	`203`	`ar(CEREAL_NVP(sizeMult));`
`199`		`- ar(CEREAL_NVP(backIdxs));`
`200`	`204`	`}`
`201`	`205`
`202`	`206`	`} // namespace mlpack`