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

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

@@ -0,0 +1,143 @@
+/**
+ * @file methods/ann/layer/sum_reduce_impl.hpp
+ * @author Andrew Furey
+ *
+ * Definition of the SumReduce class sums inputs along a given axis.
+ *
+ * mlpack is free software; you may redistribute it and/or modify it under the
+ * terms of the 3-clause BSD license.  You should have received a copy of the
+ * 3-clause BSD license along with mlpack.  If not, see
+ * http://www.opensource.org/licenses/BSD-3-Clause for more information.
+ */
+#ifndef MLPACK_METHODS_ANN_LAYER_ADD_REDUCE_IMPL_HPP
+#define MLPACK_METHODS_ANN_LAYER_ADD_REDUCE_IMPL_HPP
+
+// In case it hasn't yet been included.
+#include "sum_reduce.hpp"
+
+namespace mlpack {
+
+template<typename MatType>
+SumReduce<MatType>::SumReduce(size_t axis, bool keepDimensions) :
+    Layer<MatType>(),
+    axis(axis),
+    keepDimensions(keepDimensions)
+{
+  // Nothing to do.
+}
+
+template<typename MatType>
+SumReduce<MatType>::SumReduce(const SumReduce& other) :
+    Layer<MatType>(other),
+    axis(other.axis),
+    keepDimensions(other.keepDimensions)
+{
+  // Nothing to do.
+}
+
+template<typename MatType>
+SumReduce<MatType>::SumReduce(SumReduce&& other) :
+    Layer<MatType>(std::move(other)),
+    axis(std::move(other.axis)),
+    keepDimensions(std::move(other.keepDimensions))
+{
+  // Nothing to do.
+}
+
+template<typename MatType>
+SumReduce<MatType>&
+SumReduce<MatType>::operator=(const SumReduce& other)
+{
+  if (&other != this)
+  {
+    Layer<MatType>::operator=(other);
+    axis = other.axis;
+    keepDimensions = other.keepDimensions;
+  }
+
+  return *this;
+}
+
+template<typename MatType>
+SumReduce<MatType>&
+SumReduce<MatType>::operator=(SumReduce&& other)
+{
+  if (&other != this)
+  {
+    Layer<MatType>::operator=(std::move(other));
+    axis = std::move(other.axis);
+    keepDimensions = std::move(other.keepDimensions);
+  }
+
+  return *this;
+}
+
+template<typename MatType>
+void SumReduce<MatType>::Forward(const MatType& input, MatType& output)
+{
+  CubeType inputAlias;
+  MakeAlias(inputAlias, input, rows, this->inputDimensions[axis],
+    slices * input.n_cols);
+  output = reshape((MatType)sum(inputAlias, 1),
+    input.n_rows / this->inputDimensions[axis], input.n_cols);
+}
+
+template<typename MatType>
+void SumReduce<MatType>::Backward(
+    const MatType& input,
+    const MatType& /* output */,
+    const MatType& gy,
+    MatType& g)
+{
+  g.set_size(input.n_rows, input.n_cols);
+  CubeType gAlias;
+  MakeAlias(gAlias, g, rows, this->inputDimensions[axis],
+    slices * input.n_cols);
+
+  CubeType gyAlias;
+  MakeAlias(gyAlias, gy, rows, 1, slices * gy.n_cols);
+
+  for (size_t i = 0; i < this->inputDimensions[axis]; i++)
+    gAlias.col(i) = gyAlias;
+}
+
+template<typename MatType>
+void SumReduce<MatType>::ComputeOutputDimensions()
+{
+  if (axis >= this->inputDimensions.size())
+  {
+    std::ostringstream errMessage;
+    errMessage << "SumReduce::ComputeOutputDimensions(): Cannot "
+        << "sum along axis " << axis << " when there are "
+        << this->inputDimensions.size() << " input dimensions.";
+    throw std::logic_error(errMessage.str());
+  }
+  this->outputDimensions = this->inputDimensions;
+
+  if (keepDimensions || this->outputDimensions.size() == 1)
+    this->outputDimensions[axis] = 1;
+  else
+    this->outputDimensions.erase(this->outputDimensions.begin() + axis);
+
+  rows = 1;
+  for (size_t i = 0; i < axis; i++)
+    rows *= this->inputDimensions[i];
+
+  slices = 1;
+  for (size_t i = axis + 1; i < this->inputDimensions.size(); i++)
+    slices *= this->inputDimensions[i];
+}
+
+template<typename MatType>
+template<typename Archive>
+void SumReduce<MatType>::serialize(Archive& ar,
+  const uint32_t /* version */)
+{
+  ar(cereal::base_class<Layer<MatType>>(this));
+  ar(CEREAL_NVP(axis));
+  ar(CEREAL_NVP(keepDimensions));
+}
+
+} // namespace mlpack
+
+#endif

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

@@ -34,7 +34,7 @@ typename MatType::elem_type CosineEmbeddingLossType<MatType>::Forward(
 
   const size_t cols = prediction.n_cols;
   const size_t batchSize = prediction.n_elem / cols;
-  if (arma::size(prediction) != arma::size(target))
+  if (size(prediction) != size(target))
     Log::Fatal << "Input Tensors must have same dimensions." << std::endl;
 
   arma::Col<ElemType> inputTemp1 = vectorise(prediction);
@@ -72,12 +72,12 @@ void CosineEmbeddingLossType<MatType>::Backward(
 
   const size_t cols = prediction.n_cols;
   const size_t batchSize = prediction.n_elem / cols;
-  if (arma::size(prediction) != arma::size(target))
+  if (size(prediction) != size(target))
     Log::Fatal << "Input Tensors must have same dimensions." << std::endl;
 
   ColType inputTemp1 = vectorise(prediction);
   ColType inputTemp2 = vectorise(target);
-  loss.set_size(arma::size(inputTemp1));
+  loss.set_size(size(inputTemp1));
 
   ColType outputTemp;
   MakeAlias(outputTemp, loss, inputTemp1.n_elem, 0, false);

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

@@ -45,7 +45,7 @@ void MeanBiasErrorType<MatType>::Backward(
     const MatType& /* target */,
     MatType& loss)
 {
-  loss.set_size(arma::size(prediction));
+  loss.set_size(size(prediction));
   loss.fill(-1.0);
 
   if (!reduction)

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

@@ -43,7 +43,7 @@ typename MatType::elem_type MultiLabelSoftMarginLossType<MatType>::Forward(
 
   MatType logSigmoid = log((1 / (1 + exp(-input))));
   MatType logSigmoidNeg = log(1 / (1 + exp(input)));
-  MatType loss = arma::mean(sum(-(target % logSigmoid +
+  MatType loss = mean(sum(-(target % logSigmoid +
       (1 - target) % logSigmoidNeg)) % classWeights, 1);
 
   if (reduction)

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

@@ -48,8 +48,8 @@ class NegativeLogLikelihoodType
    * @param target The target vector, that contains the class index in the range
    *        between 1 and the number of classes.
    */
-  double Forward(const MatType& prediction,
-                 const MatType& target);
+  typename MatType::elem_type Forward(const MatType& prediction,
+                                      const MatType& target);
 
   /**
    * Ordinary feed backward pass of a neural network. The negative log

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

@@ -27,19 +27,27 @@ NegativeLogLikelihoodType<MatType>::NegativeLogLikelihoodType(
 }
 
 template<typename MatType>
-double NegativeLogLikelihoodType<MatType>::Forward(
+typename MatType::elem_type
+NegativeLogLikelihoodType<MatType>::Forward(
     const MatType& prediction,
     const MatType& target)
 {
   using ElemType = typename MatType::elem_type;
-  ElemType lossSum = 0;
-  for (size_t i = 0; i < prediction.n_cols; ++i)
-  {
-    Log::Assert(target(i) >= 0 && target(i) < prediction.n_rows,
-        "Target class out of range.");
 
-    lossSum -= prediction(target(i), i);
-  }
+  // Sanity check the inputs in debug mode.
+  #ifdef DEBUG
+  Log::Assert(all(vectorise(target >= ElemType(0) &&
+                            target < ElemType(prediction.n_rows))),
+      "NegativeLogLikelihood::Forward(): labels must be between 0 and "
+      "(numClasses - 1).");
+  #endif
+
+  // Assemble the indices in `prediction` we are looking for.
+  // For each i, we want to access prediction(target(i), i).
+  const ElemType lossSum = -accu(prediction.elem(
+      conv_to<typename GetUColType<MatType>::type>::from(
+          target + (prediction.n_rows * linspace<MatType>(0,
+          prediction.n_cols - 1, prediction.n_cols).t()))));
 
   if (reduction)
     return lossSum;
@@ -53,14 +61,20 @@ void NegativeLogLikelihoodType<MatType>::Backward(
       const MatType& target,
       MatType& loss)
 {
-  loss = zeros<MatType>(prediction.n_rows, prediction.n_cols);
-  for (size_t i = 0; i < prediction.n_cols; ++i)
-  {
-    Log::Assert(target(i) >= 0 && target(i) < prediction.n_rows,
-        "Target class out of range.");
+  #ifdef DEBUG
+  using ElemType = typename MatType::elem_type;
 
-    loss(target(i), i) = -1;
-  }
+  // Sanity check the inputs.
+  Log::Assert(all(vectorise(target >= ElemType(0) &&
+                            target < ElemType(prediction.n_rows))),
+      "NegativeLogLikelihood::Forward(): labels must be between 0 and "
+      "(numClasses - 1).");
+  #endif
+
+  loss = zeros<MatType>(prediction.n_rows, prediction.n_cols);
+  loss.elem(conv_to<typename GetUColType<MatType>::type>::from(
+      target + (prediction.n_rows * linspace<MatType>(0,
+      prediction.n_cols - 1, prediction.n_cols).t()))).fill(-1);
 
   if (!reduction)
     loss = loss / target.n_elem;

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

@@ -39,7 +39,7 @@ typename MatType::elem_type PoissonNLLLossType<MatType>::Forward(
     const MatType& prediction,
     const MatType& target)
 {
-  MatType loss(arma::size(prediction));
+  MatType loss(size(prediction));
 
   if (logInput)
     loss = exp(prediction) - target % prediction;

mlpack/include/mlpack/methods/ann/models/models.hpp

@@ -0,0 +1,17 @@
+/**
+ * @file methods/ann/models/models.hpp
+ * @author Andrew Furey
+ *
+ * This includes all prebuilt models found in mlpack.
+ *
+ * mlpack is free software; you may redistribute it and/or modify it under the
+ * terms of the 3-clause BSD license.  You should have received a copy of the
+ * 3-clause BSD license along with mlpack.  If not, see
+ * http://www.opensource.org/licenses/BSD-3-Clause for more information.
+ */
+#ifndef MLPACK_METHODS_ANN_MODELS_MODELS_HPP
+#define MLPACK_METHODS_ANN_MODELS_MODELS_HPP
+
+#include "yolov3/yolov3_tiny.hpp"
+
+#endif

mlpack/include/mlpack/methods/ann/models/yolov3/yolov3_layer.hpp

@@ -0,0 +1,151 @@
+/**
+ * @file methods/ann/models/yolov3/yolov3_layer.hpp
+ * @author Andrew Furey
+ *
+ * Definition of the YOLOv3 layer.
+ *
+ * mlpack is free software; you may redistribute it and/or modify it under the
+ * terms of the 3-clause BSD license.  You should have received a copy of the
+ * 3-clause BSD license along with mlpack.  If not, see
+ * http://www.opensource.org/licenses/BSD-3-Clause for more information.
+ */
+#ifndef MLPACK_METHODS_ANN_MODELS_YOLOV3_YOLOV3_LAYER_HPP
+#define MLPACK_METHODS_ANN_MODELS_YOLOV3_YOLOV3_LAYER_HPP
+
+#include <mlpack/prereqs.hpp>
+#include <mlpack/methods/ann/layer/layer.hpp>
+
+/**
+ * Helper layer for YOLOv3. Used as the last layer to normalize bounding
+ * boxes and classification probilities.
+ *
+ * Returns bounding boxes in YOLO format. Bounding boxes consist of
+ * a center x and center y coordinate, width and height, objectness score
+ * and class probabilities.
+ *
+ * This layer outputs `gridSize` x `gridSize` x `predictionsPerCell`
+ * bounding boxes.
+ *
+ * For more information, refer to the following paper:
+ *
+ * @code
+ * @article{yolov3,
+ *   title     = {YOLOv3: An Incremental Improvement},
+ *   author    = {Redmon, Joseph and Farhadi, Ali},
+ *   journal   = {arXiv},
+ *   year      = {2018}
+ * }
+ * @endcode
+ *
+ */
+namespace mlpack {
+
+template <typename MatType = arma::mat>
+class YOLOv3Layer : public Layer<MatType>
+{
+ public:
+  using ElemType = typename MatType::elem_type;
+
+  using CubeType = typename GetCubeType<MatType>::type;
+
+  YOLOv3Layer() { /* Nothing to do. */ }
+
+  /**
+   * YOLOv3Layer constructor.
+   *
+   * Input dimensions are expected to be 3d, normally from the outputs of a
+   * convolution layer.
+   *
+   * @param imgSize The width and height of input images. Pretrained weights
+       used 416.
+   * @param numAttributes Total number of attributes representing a bounding
+       box. The same as 5 plus the number of classes in the dataset.
+   * @param predictionsPerCell Each YOLO layer predicts `predictionsPerCell`
+       boxes per grid cell. Pretrained weights use 3.
+   * @param anchors Vector of anchor width and heights. Formatted as
+      [w0, h0, w1, h1, ... ]. Each anchors is a [w, h] pair. There must be
+      `predictionsPerCell` anchor pairs.
+   */
+  YOLOv3Layer(const size_t imgSize,
+              const size_t numAttributes,
+              const size_t gridSize,
+              const size_t predictionsPerCell,
+              const std::vector<ElemType>& anchors);
+
+  YOLOv3Layer* Clone() const override { return new YOLOv3Layer(*this); }
+
+  // Copy the given YOLOv3Layer.
+  YOLOv3Layer(const YOLOv3Layer& other);
+  // Take ownership of the given YOLOv3Layer.
+  YOLOv3Layer(YOLOv3Layer&& other);
+  // Copy the given YOLOv3Layer.
+  YOLOv3Layer& operator=(const YOLOv3Layer& other);
+  // Take ownership of the given YOLOv3Layer.
+  YOLOv3Layer& operator=(YOLOv3Layer&& other);
+
+  void ComputeOutputDimensions() override;
+
+  /**
+   * NOTE: This will be changed when training is implemented.
+   *
+   * Takes in 3d input and outputs bounding boxes, based on anchors,
+   * input image size and cell position, for each batch item.
+   *
+   * Bounding boxes are outputted in the format: x1, y1, x2, y2.
+   *
+   * @param input Input data representing outputs of model.
+   * @param output Resulting bounding boxes after being normalized to image.
+   */
+  void Forward(const MatType& input, MatType& output) override;
+
+  /**
+   * NOTE: This will be changed when training is implemented.
+   *
+   * Currently not implemented.
+   */
+  void Backward(const MatType& input,
+                const MatType& output,
+                const MatType& gy,
+                MatType& g) override;
+
+  // Serialize the layer.
+  template<typename Archive>
+  void serialize(Archive& ar, const uint32_t /* version */);
+
+ private:
+  void GenerateAnchors()
+  {
+    anchorsW = MatType(grid, predictionsPerCell, arma::fill::none);
+    anchorsH = MatType(grid, predictionsPerCell, arma::fill::none);
+
+    for (size_t i = 0; i < predictionsPerCell; i++)
+    {
+      anchorsW.col(i).fill(anchors[i * 2]);
+      anchorsH.col(i).fill(anchors[i * 2 + 1]);
+    }
+  }
+
+  // Original input image size.
+  size_t imgSize;
+  // Number of attributes representing a bounding box.
+  size_t numAttributes;
+  // Width and height of grid, since grids must be square.
+  // Should be equivalent to inputDimensions[0] and inputdDimensions[1].
+  size_t gridSize;
+  // Cached gridSize * gridSize
+  size_t grid;
+  // Vector of anchor pairs.
+  std::vector<ElemType> anchors;
+  // Number of bounding boxes per cell.
+  size_t predictionsPerCell;
+  // Matrix of anchor widths.
+  MatType anchorsW;
+  // Matrix of anchor height.
+  MatType anchorsH;
+};
+
+} // namespace mlpack
+
+#include "yolov3_layer_impl.hpp"
+
+#endif