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

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

@@ -0,0 +1,265 @@
+/**
+ * @file methods/ann/models/yolov3/yolov3_layer_impl.hpp
+ * @author Andrew Furey
+ *
+ * Implementation 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_IMPL_HPP
+#define MLPACK_METHODS_ANN_MODELS_YOLOV3_YOLOV3_LAYER_IMPL_HPP
+
+#include "yolov3_layer.hpp"
+
+namespace mlpack {
+
+template <typename MatType>
+YOLOv3Layer<MatType>::YOLOv3Layer(
+    const size_t imgSize,
+    const size_t numAttributes,
+    const size_t gridSize,
+    const size_t predictionsPerCell,
+    const std::vector<ElemType>& anchors) :
+    Layer<MatType>(),
+    imgSize(imgSize),
+    numAttributes(numAttributes),
+    gridSize(gridSize),
+    grid(gridSize * gridSize),
+    anchors(anchors),
+    predictionsPerCell(predictionsPerCell)
+{
+  if (anchors.size() != 2 * predictionsPerCell)
+  {
+    std::ostringstream errMessage;
+    errMessage << "YOLOv3 must have " << predictionsPerCell
+                << " (w, h) anchors but you gave "
+                << anchors.size() / 2 << ".";
+    throw std::logic_error(errMessage.str());
+  }
+
+  GenerateAnchors();
+}
+
+template<typename MatType>
+YOLOv3Layer<MatType>::
+YOLOv3Layer(const YOLOv3Layer& other) :
+    Layer<MatType>(),
+    imgSize(other.imgSize),
+    numAttributes(other.numAttributes),
+    gridSize(other.gridSize),
+    grid(other.grid),
+    anchors(other.anchors),
+    predictionsPerCell(other.predictionsPerCell)
+{
+  // Nothing to do here.
+  GenerateAnchors();
+}
+
+template<typename MatType>
+YOLOv3Layer<MatType>::
+YOLOv3Layer(YOLOv3Layer&& other) :
+    Layer<MatType>(std::move(other)),
+    imgSize(std::move(imgSize)),
+    numAttributes(std::move(numAttributes)),
+    gridSize(std::move(gridSize)),
+    grid(std::move(grid)),
+    anchors(std::move(anchors)),
+    predictionsPerCell(std::move(predictionsPerCell))
+{
+  // Nothing to do here.
+  GenerateAnchors();
+}
+
+template<typename MatType>
+YOLOv3Layer<MatType>&
+YOLOv3Layer<MatType>::
+operator=(const YOLOv3Layer& other)
+{
+  if (&other != this)
+  {
+    Layer<MatType>::operator=(other);
+    imgSize = other.imgSize;
+    numAttributes = other.numAttributes;
+    gridSize = other.gridSize;
+    grid = other.grid;
+    anchors = other.anchors;
+    predictionsPerCell = other.predictionsPerCell;
+    GenerateAnchors();
+  }
+  return *this;
+}
+
+template<typename MatType>
+YOLOv3Layer<MatType>&
+YOLOv3Layer<MatType>::
+operator=(YOLOv3Layer&& other)
+{
+  if (&other != this)
+  {
+    Layer<MatType>::operator=(std::move(other));
+    imgSize = std::move(other.imgSize);
+    numAttributes = std::move(other.numAttributes);
+    gridSize = std::move(other.gridSize);
+    grid = std::move(other.grid);
+    anchors = std::move(anchors);
+    predictionsPerCell = std::move(other.predictionsPerCell);
+    GenerateAnchors();
+  }
+  return *this;
+}
+
+template <typename MatType>
+void YOLOv3Layer<MatType>::ComputeOutputDimensions()
+{
+  if (this->inputDimensions.size() != 3)
+  {
+    std::ostringstream errMessage;
+    errMessage << "YOLOv3Layer::ComputeOutputDimensions(): "
+               << "Input dimensions must be 3D, but there are "
+               << this->inputDimensions.size() << " input "
+               << "dimensions";
+    throw std::logic_error(errMessage.str());
+  }
+
+  if (this->inputDimensions[0] != this->inputDimensions[1])
+    throw std::logic_error("YOLOv3Layer::ComputeOutputDimensions(): "
+      "Input dimensions must be square.");
+
+  if (gridSize != this->inputDimensions[0] ||
+      gridSize != this->inputDimensions[1])
+  {
+    std::ostringstream errMessage;
+    errMessage << "YOLOv3Layer::ComputeOutputDimensions(): "
+      << "Expected grid size was " << gridSize << " but input dimensions were "
+      << this->inputDimensions[0] << " x " << this->inputDimensions[1];
+    throw std::logic_error(errMessage.str());
+  }
+
+  this->outputDimensions = { numAttributes, grid * predictionsPerCell };
+}
+
+template <typename MatType>
+void YOLOv3Layer<MatType>::Forward(const MatType& input, MatType& output)
+{
+  ElemType stride = imgSize / (ElemType)(gridSize);
+  size_t batchSize = input.n_cols;
+  output.set_size(input.n_rows, batchSize);
+
+  CubeType inputCube;
+  MakeAlias(inputCube, input, grid * numAttributes, predictionsPerCell,
+    batchSize);
+
+  CubeType outputCube(grid * numAttributes, predictionsPerCell, batchSize,
+    arma::fill::zeros);
+
+  CubeType reshapedCube;
+  MakeAlias(reshapedCube, output, numAttributes,
+    predictionsPerCell * grid, batchSize);
+
+  // Input dimensions: gridSize
+  MatType offset = arma::regspace<MatType>(0, gridSize - 1);
+
+#if ARMA_VERSION_MAJOR < 15
+  // If arma::repcube is not available
+  CubeType anchorsWBS(anchorsW.n_rows, anchorsW.n_cols, batchSize);
+  CubeType anchorsHBS(anchorsH.n_rows, anchorsH.n_cols, batchSize);
+  CubeType xOffset(grid, predictionsPerCell, batchSize);
+
+  arma::Col<ElemType> offsetT =
+    arma::vectorise(arma::repmat(offset.t(), gridSize, 1));
+  CubeType yOffset(grid, predictionsPerCell, batchSize);
+  for (size_t i = 0; i < batchSize; i++)
+  {
+    anchorsWBS.slice(i) = anchorsW;
+    anchorsHBS.slice(i) = anchorsH;
+    xOffset.slice(i) = arma::repmat(offset, gridSize, predictionsPerCell);
+    yOffset.slice(i) = arma::repmat(offsetT, 1, predictionsPerCell);
+  }
+#else
+  CubeType anchorsWBS = arma::repcube(anchorsW, 1, 1, batchSize);
+  CubeType anchorsHBS = arma::repcube(anchorsH, 1, 1, batchSize);
+  CubeType xOffset = arma::repcube(offset, gridSize,
+    predictionsPerCell, batchSize);
+
+  CubeType yOffset = arma::repcube(
+    arma::vectorise(arma::repmat(offset.t(), gridSize, 1)),
+    1, predictionsPerCell, batchSize);
+#endif
+
+  // TODO: add if (this->training). Add check for different batchSize.
+  const size_t cols = predictionsPerCell - 1;
+
+  // x1
+  outputCube.tube(0, 0, grid - 1, cols) =
+    (xOffset + 1 / (1 + arma::exp(-inputCube.tube(0, 0, grid - 1, cols))))
+    * stride
+    - anchorsWBS % arma::exp(inputCube.tube(grid * 2, 0, grid * 3 - 1, cols))
+    / 2;
+
+  // y1
+  outputCube.tube(grid, 0, grid * 2 - 1, cols) = (yOffset + 1 /
+    (1 + arma::exp(-inputCube.tube(grid, 0, grid * 2 - 1, cols)))) * stride
+    - anchorsHBS % arma::exp(inputCube.tube(grid * 3, 0, grid * 4 - 1, cols))
+    / 2;
+
+  // x2
+  outputCube.tube(grid * 2, 0, grid * 3 - 1, cols) =
+    (xOffset + 1 / (1 + arma::exp(-inputCube.tube(0, 0, grid - 1, cols))))
+    * stride
+    + anchorsWBS % arma::exp(inputCube.tube(grid * 2, 0, grid * 3 - 1, cols))
+    / 2;
+
+  // y2
+  outputCube.tube(grid * 3, 0, grid * 4 - 1, cols) = (yOffset + 1 /
+    (1 + arma::exp(-inputCube.tube(grid, 0, grid * 2 - 1, cols)))) * stride
+    + anchorsHBS % arma::exp(inputCube.tube(grid * 3, 0, grid * 4 - 1, cols))
+    / 2;
+
+  // apply logistic sigmoid to objectness and classification logits.
+  outputCube.tube(grid * 4, 0, outputCube.n_rows - 1, cols) = 1. /
+    (1 + arma::exp(-inputCube.tube(grid * 4, 0, inputCube.n_rows - 1, cols)));
+
+  // Reshape, for each batch item.
+  for (size_t i = 0; i < reshapedCube.n_slices; i++)
+  {
+    reshapedCube.slice(i) = arma::reshape(
+      arma::reshape(
+        outputCube.slice(i), grid, numAttributes * predictionsPerCell).t(),
+        numAttributes, predictionsPerCell * grid);
+  }
+}
+
+template <typename MatType>
+void YOLOv3Layer<MatType>::Backward(
+    const MatType& /* input */,
+    const MatType& /* output */,
+    const MatType& /* gy */,
+    MatType& /* g */)
+{
+  throw std::runtime_error("YOLOv3Layer::Backward() not implemented.");
+}
+
+template <typename MatType>
+template <typename Archive>
+void YOLOv3Layer<MatType>::serialize(Archive& ar, const uint32_t /* version */)
+{
+  ar(cereal::base_class<Layer<MatType>>(this));
+  ar(CEREAL_NVP(imgSize));
+  ar(CEREAL_NVP(numAttributes));
+  ar(CEREAL_NVP(gridSize));
+  ar(CEREAL_NVP(grid));
+  ar(CEREAL_NVP(anchors));
+  ar(CEREAL_NVP(predictionsPerCell));
+
+  if (Archive::is_loading::value)
+  {
+    GenerateAnchors();
+  }
+}
+
+} // namespace mlpack
+
+#endif

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

@@ -0,0 +1,187 @@
+/**
+ * @file methods/ann/models/yolov3_tiny.hpp
+ * @author Andrew Furey
+ *
+ * Definition of the YOLOv3-tiny model.
+ *
+ * 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_TINY_HPP
+#define MLPACK_METHODS_ANN_MODELS_YOLOV3_TINY_HPP
+
+#include <mlpack/prereqs.hpp>
+
+#include <mlpack/methods/ann/dag_network.hpp>
+#include <mlpack/methods/ann/loss_functions/loss_functions.hpp>
+#include <mlpack/methods/ann/init_rules/init_rules.hpp>
+
+#include <mlpack/methods/ann/layer/layer_types.hpp>
+#include <mlpack/methods/ann/models/yolov3/yolov3_layer.hpp>
+
+namespace mlpack {
+
+/**
+ * YOLOv3-tiny is a small one-stage object detection model.
+ *
+ * The input to the model must be a square image. Look at image_letterbox.hpp
+ * to preprocess images before inference.
+ *
+ * The output of the model is a matrix. The rows are data points per
+ * bounding box (including x, y, w, h, objectness, and classifications).
+ * The columns represent each bounding box.
+ *
+ * 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
+ *
+ */
+template <typename OutputLayerType = EmptyLoss,
+          typename InitializationRuleType = RandomInitialization,
+          typename MatType = arma::mat>
+class YOLOv3Tiny
+{
+ public:
+  // Helper types.
+  using ModelType =
+    DAGNetwork<OutputLayerType, InitializationRuleType, MatType>;
+  using ElemType = typename MatType::elem_type;
+  using CubeType = typename GetCubeType<MatType>::type;
+
+  YOLOv3Tiny() { /* Nothing to do. */ }
+
+  /**
+   * Create the YOLOv3Tiny model.
+   *
+   * @param imgSize The width and height of input images. Pretrained weights
+       used 416.
+   * @param numClasses The number of output classes. Pretrained weights were
+       trained on COCO which has 80 classes.
+   * @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 * 2 anchors, since YOLOv3Tiny has two output layers.
+      Therefore, anchors.size() must be predictionsPerCell * 4.
+   */
+  YOLOv3Tiny(const size_t imgSize,
+             const size_t numClasses,
+             const size_t predictionsPerCell,
+             const size_t maxDetections,
+             const std::vector<ElemType>& anchors);
+
+  ~YOLOv3Tiny() { /* Nothing to do. */ }
+
+  /**
+   * Returns the graph representation of the model.
+   */
+  ModelType& Model() { return model; }
+
+  /**
+   * Ordinary feed forward pass of the network.
+   *
+   * @param input Input data used for evaluating the specified function.
+      The input matrix dimensions should be (imgSize * imgSize, batchSize).
+   * @param output Resulting bounding boxes.
+   * @param numDetections Number of bounding boxes in output per batch.
+   */
+  void Predict(const MatType& input,
+               MatType& output,
+               arma::ucolvec& numDetections)
+  {
+    const size_t batchSize = input.n_cols;
+    MatType batchedOutput;
+    model.Predict(input, batchedOutput);
+
+    CubeType batchedOutputAlias;
+    MakeAlias(batchedOutputAlias, batchedOutput,
+              numAttributes, numBoxes, batchSize);
+
+    output = MatType(numAttributes * maxDetections, batchSize,
+                     arma::fill::zeros);
+    CubeType outputAlias;
+    MakeAlias(outputAlias, output,
+              numAttributes, maxDetections, batchSize);
+
+    numDetections = arma::ucolvec(batchSize, arma::fill::zeros);
+    for (size_t i = 0; i < batchSize; i++)
+    {
+      arma::ucolvec indices;
+
+      const MatType& bboxes = batchedOutputAlias.slice(i);
+      const MatType& confs = batchedOutputAlias.slice(i).row(4).t();
+      NMS<true>::Evaluate<MatType, MatType, arma::ucolvec>
+        (bboxes, confs, indices);
+
+      numDetections(i) = std::min<size_t>(maxDetections, indices.n_rows);
+      for (size_t j = 0; j < numDetections(i); j++)
+      {
+        outputAlias.slice(i).col(j) =
+          batchedOutputAlias.slice(i).col(indices(j));
+      }
+    }
+  }
+
+  // Serialize the model.
+  template<typename Archive>
+  void serialize(Archive& ar, const uint32_t /* version */);
+
+ private:
+  /**
+   * Adds a MultiLayer to the internal DAGNetwork. The MultiLayer includes
+   * a Convolutions, BatchNorm (if batchNorm is true) and LeakyReLU.
+   * If batchNorm is true, the convolution layer will not have a bias,
+   * otherwise it will.
+   * 
+   * The convolution kernel size must be 3 or 1. If the kernel size is 3,
+   * padding will be added.
+   *
+   * @param maps Number of output maps of the convolution layer.
+   * @param kernel Size of the convolution kernel
+   * @param batchNorm Boolean for including a batchnorm layer.
+   * @param reluSlope Slope used in LeakyReLU. Default is 0.1 because
+      pretrained weights used 0.1.
+   */
+  size_t ConvolutionBlock(const size_t maps,
+                          const size_t kernel,
+                          const bool batchNorm = true,
+                          const ElemType reluSlope = 0.1);
+
+  /**
+   * Adds a MultiLayer to the internal DAGNetwork. The MultiLayer includes
+   * a MaxPooling layer and an optional Padding layer depending on the stride
+   * size.
+   *
+   * @param stride Stride of the MaxPooling kernel.
+   */
+  size_t MaxPool2x2(const size_t stride);
+
+  // DAGNetwork containing the graph of the YOLOv3Tiny model
+  ModelType model;
+  // Width and height of input image
+  size_t imgSize;
+  // Predictions per cell for each YOLO layer
+  size_t predictionsPerCell;
+  // Number of output classes + 5 for (x, y, w, h, objectness)
+  size_t numAttributes;
+  // Max detections used during batched inference, because NMS returns variable
+  // number of outputs.
+  size_t maxDetections;
+  // Total number of boxes
+  size_t numBoxes;
+};
+
+} // namespace mlpack
+
+#include "yolov3_tiny_impl.hpp"
+
+#endif

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

@@ -0,0 +1,206 @@
+/**
+ * @file methods/ann/models/yolov3/yolov3_tiny_impl.hpp
+ * @author Andrew Furey
+ *
+ * Definition of the YOLOv3-tiny model.
+ *
+ * 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_YOLOV3_TINY_IMPL_HPP
+#define MLPACK_METHODS_ANN_MODELS_MODELS_YOLOV3_TINY_IMPL_HPP
+
+#include <mlpack/methods/ann/models/yolov3/yolov3_tiny.hpp>
+
+namespace mlpack {
+
+template <typename OutputLayerType,
+          typename InitializationRuleType,
+          typename MatType>
+YOLOv3Tiny<
+           OutputLayerType,
+           InitializationRuleType,
+           MatType
+>::YOLOv3Tiny(const size_t imgSize,
+              const size_t numClasses,
+              const size_t predictionsPerCell,
+              const size_t maxDetections,
+              const std::vector<ElemType>& anchors) :
+  imgSize(imgSize),
+  predictionsPerCell(predictionsPerCell),
+  numAttributes(numClasses + 5),
+  maxDetections(maxDetections)
+{
+  if (anchors.size() != predictionsPerCell * 4)
+  {
+    std::ostringstream errMessage;
+    errMessage << "YOLOv3Tiny::YOLOv3Tiny(): Expected " << predictionsPerCell *
+      4 << " anchor points, but received " << anchors.size();
+    throw std::logic_error(errMessage.str());
+  }
+
+  const size_t mid = predictionsPerCell * 2;
+  numBoxes = (imgSize / 16) * (imgSize / 16) * predictionsPerCell +
+             (imgSize / 32) * (imgSize / 32) * predictionsPerCell;
+
+  const std::vector<ElemType>
+    smallAnchors(anchors.begin(), anchors.begin() + mid),
+    largeAnchors(anchors.begin() + mid, anchors.end());
+
+  const std::vector<double> scaleFactor = { 2.0, 2.0 };
+
+  model = Model();
+  model.InputDimensions() = { imgSize, imgSize, 3 };
+
+  size_t convolution0 = ConvolutionBlock(16, 3);
+  size_t maxPool1 = MaxPool2x2(2);
+  size_t convolution2 = ConvolutionBlock(32, 3);
+  size_t maxPool3 = MaxPool2x2(2);
+  size_t convolution4 = ConvolutionBlock(64, 3);
+  size_t maxPool5 = MaxPool2x2(2);
+  size_t convolution6 = ConvolutionBlock(128, 3);
+  size_t maxPool7 = MaxPool2x2(2);
+  size_t convolution8 = ConvolutionBlock(256, 3);
+  size_t maxPool9 = MaxPool2x2(2);
+  size_t convolution10 = ConvolutionBlock(512, 3);
+  size_t maxPool11 = MaxPool2x2(1);
+  size_t convolution12 = ConvolutionBlock(1024, 3);
+  size_t convolution13 = ConvolutionBlock(256, 1);
+
+  // Detection head for larger objects.
+  size_t convolution14 = ConvolutionBlock(512, 3);
+  size_t convolution15 =
+    ConvolutionBlock(predictionsPerCell * numAttributes, 1, false);
+  size_t detections16 =
+    model.template Add<YOLOv3Layer<MatType>>(imgSize, numAttributes,
+      imgSize / 32, predictionsPerCell, largeAnchors);
+
+  size_t convolution17 = ConvolutionBlock(128, 1);
+  // Upsample for more fine-grained detections.
+  size_t upsample18 =
+    model.template Add<NearestInterpolation<MatType>>(scaleFactor);
+
+  // Detection head for smaller objects.
+  size_t convolution19 = ConvolutionBlock(256, 3);
+  size_t convolution20 =
+    ConvolutionBlock(predictionsPerCell * numAttributes, 1, false);
+  size_t detections21 =
+    model.template Add<YOLOv3Layer<MatType>>(imgSize, numAttributes,
+      imgSize / 16, predictionsPerCell, smallAnchors);
+
+
+  // the DAGNetwork class requires one explicit output layer for concatenations,
+  // so we use the Identity layer for pure concatentation, and no other compute.
+  size_t concatLayer22 = model.template Add<Identity<MatType>>();
+
+  model.Connect(convolution0, maxPool1);
+  model.Connect(maxPool1, convolution2);
+  model.Connect(convolution2, maxPool3);
+  model.Connect(maxPool3, convolution4);
+  model.Connect(convolution4, maxPool5);
+  model.Connect(maxPool5, convolution6);
+  model.Connect(convolution6, maxPool7);
+  model.Connect(maxPool7, convolution8);
+
+  model.Connect(convolution8, maxPool9);
+  model.Connect(maxPool9, convolution10);
+  model.Connect(convolution10, maxPool11);
+  model.Connect(maxPool11, convolution12);
+  model.Connect(convolution12, convolution13);
+
+  model.Connect(convolution13, convolution14);
+  model.Connect(convolution14, convolution15);
+  model.Connect(convolution15, detections16);
+
+  model.Connect(convolution13, convolution17);
+  model.Connect(convolution17, upsample18);
+
+  // Concat convolution8 + upsample18 => convolution19
+  model.Connect(upsample18, convolution19);
+  model.Connect(convolution8, convolution19);
+  // Set axis not necessary, since default is concat along channels.
+
+  model.Connect(convolution19, convolution20);
+  model.Connect(convolution20, detections21);
+  // Again, set axis not necessary, since default is concat along channels.
+
+  // Concatenation order shouldn't matter.
+  model.Connect(detections16, concatLayer22);
+  model.Connect(detections21, concatLayer22);
+
+  model.SetNetworkMode(false);
+  model.Reset();
+}
+
+template <typename OutputLayerType,
+          typename InitializationRuleType,
+          typename MatType>
+size_t YOLOv3Tiny<OutputLayerType, InitializationRuleType, MatType>
+::ConvolutionBlock(const size_t maps,
+                   const size_t kernel,
+                   const bool batchNorm,
+                   const ElemType reluSlope)
+{
+  if (kernel != 3 && kernel != 1)
+  {
+    std::ostringstream errMessage;
+    errMessage << "Kernel size for convolutions in yolov3-tiny must be 3"
+        "or 1, but you gave " << kernel;
+    throw std::logic_error(errMessage.str());
+  }
+
+  size_t pad = kernel == 3 ? 1 : 0;
+  MultiLayer<MatType> block;
+  block.template Add<Convolution<MatType>>(
+    maps, kernel, kernel, 1, 1, pad, pad, "none", !batchNorm);
+
+  // set epsilon to zero, not used in darknet.
+  if (batchNorm)
+    block.template Add<BatchNorm<MatType>>(2, 2, 0, false);
+
+  block.template Add<LeakyReLU<MatType>>(reluSlope);
+  return model.Add(block);
+}
+
+template <typename OutputLayerType,
+          typename InitializationRuleType,
+          typename MatType>
+size_t YOLOv3Tiny<OutputLayerType, InitializationRuleType, MatType>
+::MaxPool2x2(const size_t stride)
+{
+  // All max pool layers have kernel size 2
+  MultiLayer<MatType> block;
+  if (stride == 1)
+  {
+    // One layer with odd input size, with kernel size 2, stride 1.
+    // Padding on the right and bottom are needed.
+    ElemType min = -arma::Datum<ElemType>::inf;
+    block.template Add<Padding<MatType>>(0, 1, 0, 1, min);
+  }
+  block.template Add<MaxPooling<MatType>>(2, 2, stride, stride);
+  return model.Add(block);
+}
+
+template<typename OutputLayerType,
+         typename InitializationRuleType,
+         typename MatType>
+template<typename Archive>
+void YOLOv3Tiny<
+    OutputLayerType,
+    InitializationRuleType,
+    MatType
+>::serialize(Archive& ar, const uint32_t /* version */)
+{
+  ar(CEREAL_NVP(model));
+  ar(CEREAL_NVP(imgSize));
+  ar(CEREAL_NVP(predictionsPerCell));
+  ar(CEREAL_NVP(numAttributes));
+  ar(CEREAL_NVP(maxDetections));
+  ar(CEREAL_NVP(numBoxes));
+}
+
+} // namespace mlpack
+
+#endif

mlpack/include/mlpack/methods/ann/regularizer/orthogonal_regularizer_impl.hpp

@@ -26,7 +26,9 @@ inline OrthogonalRegularizer::OrthogonalRegularizer(double factor) :
 template<typename MatType>
 void OrthogonalRegularizer::Evaluate(const MatType& weight, MatType& gradient)
 {
-  arma::mat grad = zeros(arma::size(weight));
+  typedef typename MatType::elem_type ElemType;
+
+  MatType grad = zeros(size(weight));
 
   for (size_t i = 0; i < weight.n_rows; ++i)
   {
@@ -34,13 +36,13 @@ void OrthogonalRegularizer::Evaluate(const MatType& weight, MatType& gradient)
     {
       if (i == j)
       {
-        double s = arma::as_scalar(
+        ElemType s = arma::as_scalar(
             sign((weight.row(i) * weight.row(i).t()) - 1));
         grad.row(i) += 2 * s * weight.row(i);
       }
       else
       {
-        double s = arma::as_scalar(sign(weight.row(i) * weight.row(j).t()));
+        ElemType s = arma::as_scalar(sign(weight.row(i) * weight.row(j).t()));
         grad.row(i) += s * weight.row(j);
         grad.row(j) += s * weight.row(i);
       }