[mlpack-git] master: Add auxiliary network function to get the size of the network. (a49e0fe)

[gitdub at mlpack.org]

Repository : https://github.com/mlpack/mlpack
On branch  : master
Link       : https://github.com/mlpack/mlpack/compare/f6dd2f7a9752a7db8ec284a938b3e84a13d0bfb2...6205f3e0b62b56452b2a4afc4da24fce5b21e72f

>---------------------------------------------------------------

commit a49e0feedb8cf04c90c742e8257410a32b6b5dfc
Author: marcus <marcus.edel at fu-berlin.de>
Date:   Fri Feb 19 14:58:41 2016 +0100

    Add auxiliary network function to get the size of the network.


>---------------------------------------------------------------

a49e0feedb8cf04c90c742e8257410a32b6b5dfc
 src/mlpack/methods/ann/network_util.hpp      | 149 +++++++++++++++++++++++
 src/mlpack/methods/ann/network_util_impl.hpp | 172 +++++++++++++++++++++++++++
 2 files changed, 321 insertions(+)

diff --git a/src/mlpack/methods/ann/network_util.hpp b/src/mlpack/methods/ann/network_util.hpp
new file mode 100644
index 0000000..c0b2227
--- /dev/null
+++ b/src/mlpack/methods/ann/network_util.hpp
@@ -0,0 +1,149 @@
+/**
+ * @file network_util.hpp
+ * @author Marcus Edel
+ *
+ * Neural network utilities.
+ */
+#ifndef __MLPACK_METHODS_ANN_NETWORK_UTIL_HPP
+#define __MLPACK_METHODS_ANN_NETWORK_UTIL_HPP
+
+#include <mlpack/core.hpp>
+
+#include <mlpack/methods/ann/layer/layer_traits.hpp>
+
+/**
+ * Neural network utility functions.
+ */
+namespace mlpack {
+namespace ann /** Artificial Neural Network. */ {
+
+/**
+ * Auxiliary function to get the number of weights of the specified network.
+ *
+ * @param network The network used for specifying the number of weights.
+ * @return The number of weights.
+ */
+template<size_t I = 0, typename... Tp>
+typename std::enable_if<I < sizeof...(Tp), size_t>::type
+NetworkSize(std::tuple<Tp...>& network);
+
+template<size_t I, typename... Tp>
+typename std::enable_if<I == sizeof...(Tp), size_t>::type
+NetworkSize(std::tuple<Tp...>& network);
+
+/**
+ * Auxiliary function to get the number of weights of the specified layer.
+ *
+ * @param layer The layer used for specifying the number of weights.
+ * @param output The layer output parameter.
+ * @return The number of weights.
+ */
+template<typename T, typename P>
+typename std::enable_if<
+    !HasWeightsCheck<T, P&(T::*)()>::value, size_t>::type
+LayerSize(T& layer, P& output);
+
+template<typename T, typename P>
+typename std::enable_if<
+    HasWeightsCheck<T, P&(T::*)()>::value, size_t>::type
+LayerSize(T& layer, P& output);
+
+/**
+ * Auxiliary function to set the weights of the specified network.
+ *
+ * @param weights The weights used to set the weights of the network.
+ * @param network The network used to set the weights.
+ * @param offset The memory offset of the weights.
+ */
+template<size_t I = 0, typename... Tp>
+typename std::enable_if<I < sizeof...(Tp), void>::type
+NetworkWeights(arma::mat& weights,
+               std::tuple<Tp...>& network,
+               size_t offset = 0);
+
+template<size_t I, typename... Tp>
+typename std::enable_if<I == sizeof...(Tp), void>::type
+NetworkWeights(arma::mat& weights,
+               std::tuple<Tp...>& network,
+               size_t offset = 0);
+
+/**
+ * Auxiliary function to set the weights of the specified layer.
+ *
+ * @param layer The layer used to set the weights.
+ * @param weights The weights used to set the weights of the layer.
+ * @param offset The memory offset of the weights.
+ * @param output The output parameter of the layer.
+ * @return The number of weights.
+ */
+template<typename T>
+typename std::enable_if<
+    HasWeightsCheck<T, arma::mat&(T::*)()>::value, size_t>::type
+LayerWeights(T& layer, arma::mat& weights, size_t offset, arma::mat& output);
+
+template<typename T>
+typename std::enable_if<
+    HasWeightsCheck<T, arma::cube&(T::*)()>::value, size_t>::type
+LayerWeights(T& layer, arma::mat& weights, size_t offset, arma::cube& output);
+
+template<typename T, typename P>
+typename std::enable_if<
+    !HasWeightsCheck<T, P&(T::*)()>::value, size_t>::type
+LayerWeights(T& layer, arma::mat& weights, size_t offset, P& output);
+
+/**
+ * Auxiliary function to set the gradients of the specified network.
+ *
+ * @param gradients The gradients used to set the gradient of the network.
+ * @param network The network used to set the gradients.
+ * @param offset The memory offset of the gradients.
+ * return The number of gradients.
+ */
+template<size_t I = 0, typename... Tp>
+typename std::enable_if<I < sizeof...(Tp), void>::type
+NetworkGradients(arma::mat& gradients,
+               std::tuple<Tp...>& network,
+               size_t offset = 0);
+
+template<size_t I, typename... Tp>
+typename std::enable_if<I == sizeof...(Tp), void>::type
+NetworkGradients(arma::mat& gradients,
+               std::tuple<Tp...>& network,
+               size_t offset = 0);
+
+/**
+ * Auxiliary function to set the gradients of the specified layer.
+ *
+ * @param layer The layer used to set the gradients.
+ * @param gradients The gradients used to set the gradient of the layer.
+ * @param offset The memory offset of the gradients.
+ * @param output The output parameter of the layer.
+ * @return The number of gradients.
+ */
+template<typename T>
+typename std::enable_if<
+    HasGradientCheck<T, arma::mat&(T::*)()>::value, size_t>::type
+LayerGradients(T& layer,
+               arma::mat& gradients,
+               size_t offset,
+               arma::mat& output);
+
+template<typename T>
+typename std::enable_if<
+    HasGradientCheck<T, arma::cube&(T::*)()>::value, size_t>::type
+LayerGradients(T& layer,
+               arma::mat& gradients,
+               size_t offset,
+               arma::cube& output);
+
+template<typename T, typename P>
+typename std::enable_if<
+    !HasGradientCheck<T, P&(T::*)()>::value, size_t>::type
+LayerGradients(T& layer, arma::mat& gradients, size_t offset, P& output);
+} // namespace ann
+} // namespace mlpack
+
+// Include implementation.
+#include "network_util_impl.hpp"
+
+#endif
diff --git a/src/mlpack/methods/ann/network_util_impl.hpp b/src/mlpack/methods/ann/network_util_impl.hpp
new file mode 100644
index 0000000..7752d1e
--- /dev/null
+++ b/src/mlpack/methods/ann/network_util_impl.hpp
@@ -0,0 +1,172 @@
+/**
+ * @file network_util_impl.hpp
+ * @author Marcus Edel
+ *
+ * Implementation of the network auxiliary functions.
+ */
+#ifndef __MLPACK_METHODS_ANN_NETWORK_UTIL_IMPL_HPP
+#define __MLPACK_METHODS_ANN_NETWORK_UTIL_IMPL_HPP
+
+#include "network_util_impl.hpp"
+
+#include <mlpack/methods/ann/layer/layer_traits.hpp>
+
+namespace mlpack {
+namespace ann {
+
+template<size_t I, typename... Tp>
+typename std::enable_if<I == sizeof...(Tp), size_t>::type
+NetworkSize(std::tuple<Tp...>& /* unused */)
+{
+  return 0;
+}
+
+template<size_t I, typename... Tp>
+typename std::enable_if<I < sizeof...(Tp), size_t>::type
+NetworkSize(std::tuple<Tp...>& network)
+{
+  return LayerSize(std::get<I>(network), std::get<I>(
+      network).OutputParameter()) + NetworkSize<I + 1, Tp...>(network);
+}
+
+template<typename T, typename P>
+typename std::enable_if<
+  HasWeightsCheck<T, P&(T::*)()>::value, size_t>::type
+LayerSize(T& layer, P& /* unused */)
+{
+  return layer.Weights().n_elem;    
+}
+
+template<typename T, typename P>
+typename std::enable_if<
+  !HasWeightsCheck<T, P&(T::*)()>::value, size_t>::type
+LayerSize(T& /* unused */, P& /* unused */)
+{
+  return 0;
+}
+
+template<size_t I, typename... Tp>
+typename std::enable_if<I < sizeof...(Tp), void>::type
+NetworkWeights(arma::mat& weights,
+               std::tuple<Tp...>& network,
+               size_t offset)
+{
+  NetworkWeights<I + 1, Tp...>(weights, network,
+      offset + LayerWeights(std::get<I>(network), weights,
+      offset, std::get<I>(network).OutputParameter()));
+  
+}
+
+template<size_t I, typename... Tp>
+typename std::enable_if<I == sizeof...(Tp), void>::type
+NetworkWeights(arma::mat& /* unused */,
+               std::tuple<Tp...>& /* unused */,
+               size_t /* unused */)
+{
+  /* Nothing to do here */
+}
+
+template<typename T>
+typename std::enable_if<
+    HasWeightsCheck<T, arma::mat&(T::*)()>::value, size_t>::type
+LayerWeights(T& layer,
+             arma::mat& weights,
+             size_t offset,
+             arma::mat& /* unused */)
+{
+  layer.Weights() = arma::mat(weights.memptr() + offset,
+      layer.Weights().n_rows, layer.Weights().n_cols, false);
+
+  return layer.Weights().n_elem;
+}
+
+template<typename T>
+typename std::enable_if<
+    HasWeightsCheck<T, arma::cube&(T::*)()>::value, size_t>::type
+LayerWeights(T& layer,
+             arma::mat& weights,
+             size_t offset,
+             arma::cube& /* unused */)
+{
+  layer.Weights() = arma::cube(weights.memptr() + offset,
+      layer.Weights().n_rows, layer.Weights().n_cols,
+      layer.Weights().n_slices, false);
+
+  return layer.Weights().n_elem;
+}
+
+template<typename T, typename P>
+typename std::enable_if<
+    !HasWeightsCheck<T, P&(T::*)()>::value, size_t>::type
+LayerWeights(T& /* unused */,
+             arma::mat& /* unused */,
+             size_t /* unused */,
+             P& /* unused */)
+{
+  return 0;
+}
+
+template<size_t I, typename... Tp>
+typename std::enable_if<I < sizeof...(Tp), void>::type
+NetworkGradients(arma::mat& gradients,
+                 std::tuple<Tp...>& network,
+                 size_t offset)
+{
+  NetworkGradients<I + 1, Tp...>(gradients, network,
+      offset + LayerGradients(std::get<I>(network), gradients,
+      offset, std::get<I>(network).OutputParameter()));
+}
+
+template<size_t I, typename... Tp>
+typename std::enable_if<I == sizeof...(Tp), void>::type
+NetworkGradients(arma::mat& /* unused */,
+               std::tuple<Tp...>& /* unused */,
+               size_t /* unused */)
+{
+  /* Nothing to do here */
+}
+
+template<typename T>
+typename std::enable_if<
+    HasGradientCheck<T, arma::mat&(T::*)()>::value, size_t>::type
+LayerGradients(T& layer,
+               arma::mat& gradients,
+               size_t offset,
+               arma::mat& /* unused */)
+{
+  layer.Gradient() = arma::mat(gradients.memptr() + offset,
+      layer.Weights().n_rows, layer.Weights().n_cols, false);
+
+  return layer.Weights().n_elem;
+}
+
+template<typename T>
+typename std::enable_if<
+    HasGradientCheck<T, arma::cube&(T::*)()>::value, size_t>::type
+LayerGradients(T& layer,
+               arma::mat& gradients,
+               size_t offset,
+               arma::cube& /* unused */)
+{
+  layer.Gradient() = arma::cube(gradients.memptr() + offset,
+      layer.Weights().n_rows, layer.Weights().n_cols,
+      layer.Weights().n_slices, false);
+
+  return layer.Weights().n_elem;
+}
+
+template<typename T, typename P>
+typename std::enable_if<
+    !HasGradientCheck<T, P&(T::*)()>::value, size_t>::type
+LayerGradients(T& /* unused */,
+               arma::mat& /* unused */,
+               size_t /* unused */,
+               P& /* unused */)
+{
+  return 0;
+}
+
+} // namespace ann
+} // namespace mlpack
+
+#endif