Formatting

sbaldu · Jan 6, 2024 · 9fb07d5 · 9fb07d5
1 parent 85e5f4a
commit 9fb07d5
Show file tree

Hide file tree

Showing 6 changed files with 63 additions and 29 deletions.
diff --git a/src/nnhep/headers/Activators.hpp b/src/nnhep/headers/Activators.hpp
@@ -76,7 +76,9 @@ namespace nnhep {
     /// @return The derivative of the identity function.
     ///
     /// @details The derivative of the identity function is always 0.
-    std::vector<double> grad(shared<Layer<T>> layer) { return std::vector<double>(layer->size(), 0.); }
+    std::vector<double> grad(shared<Layer<T>> layer) {
+      return std::vector<double>(layer->size(), 0.);
+    }
     /// @brief The derivative of the identity function.
     /// @param node_values The values of the nodes.
     /// @return The derivative of the identity function.
@@ -131,7 +133,9 @@ namespace nnhep {
     /// @brief The derivative of the linear activation function.
     /// @param layer The layer of nodes.
     /// @return The derivative of the linear activation function.
-    std::vector<double> grad(shared<Layer<T>> layer) { return std::vector<double>(layer->size(), 1); }
+    std::vector<double> grad(shared<Layer<T>> layer) {
+      return std::vector<double>(layer->size(), 1);
+    }
     /// @brief The derivative of the linear activation function.
     /// @param node_values The values of the nodes.
     /// @return The derivative of the linear activation function.
@@ -188,7 +192,9 @@ namespace nnhep {
     /// @brief The derivative of the sigmoid activation function.
     /// @param activated_value The value of the activated node.
     /// @return The derivative of the sigmoid activation function.
-    double grad(double activated_value) { return activated_value * (1 - activated_value); }
+    double grad(double activated_value) {
+      return activated_value * (1 - activated_value);
+    }
     /// @brief The derivative of the sigmoid activation function.
     /// @param layer The layer of nodes.
     /// @return The derivative of the sigmoid activation function.

diff --git a/src/nnhep/headers/ErrorFunction.hpp b/src/nnhep/headers/ErrorFunction.hpp
@@ -37,7 +37,8 @@ namespace nnhep {
     /// @details The error is calculated by taking the mean of the squared
     /// difference between the node values and the expected values.
     template <typename U>
-    double operator()(const std::vector<T>& node_values, const std::vector<U>& expected_values) {
+    double operator()(const std::vector<T>& node_values,
+                      const std::vector<U>& expected_values) {
       double error{};
       const size_t N{node_values.size()};
       for (size_t node_index{}; node_index < N; ++node_index) {
@@ -66,7 +67,8 @@ namespace nnhep {
         int N{layers[layer_id]->size()};
         std::vector<double> delta(N);
         for (int node_index{}; node_index < N; ++node_index) {
-          delta[node_index] = (*layers[layer_id])[node_index] - static_cast<T>(expected_values[node_index]);
+          delta[node_index] = (*layers[layer_id])[node_index] -
+                              static_cast<T>(expected_values[node_index]);
         }
 
         return delta;
@@ -76,9 +78,11 @@ namespace nnhep {
         std::vector<double> delta(N);
 
         for (int node_index{}; node_index < N; ++node_index) {
-          std::vector<double> previous_delta{grad(expected_values, layer_id + 1, layers, weights)};
-          delta[node_index] = act.grad((*layers[layer_id])[node_index]) *
-                              (weights[layer_id]->transpose() * previous_delta)[node_index];
+          std::vector<double> previous_delta{
+              grad(expected_values, layer_id + 1, layers, weights)};
+          delta[node_index] =
+              act.grad((*layers[layer_id])[node_index]) *
+              (weights[layer_id]->transpose() * previous_delta)[node_index];
         }
 
         return delta;

diff --git a/src/nnhep/headers/Layer.hpp b/src/nnhep/headers/Layer.hpp
@@ -80,7 +80,8 @@ namespace nnhep {
   Layer<T>::Layer(int n_nodes) : m_nodes(n_nodes), n_nodes{n_nodes} {}
 
   template <typename T>
-  Layer<T>::Layer(std::vector<T> nodes) : m_nodes{std::move(nodes)}, n_nodes{m_nodes.size()} {}
+  Layer<T>::Layer(std::vector<T> nodes)
+      : m_nodes{std::move(nodes)}, n_nodes{m_nodes.size()} {}
 
   template <typename T>
   Layer<T>::Layer(std::stringstream& stream) {
@@ -110,7 +111,8 @@ namespace nnhep {
         }
         ++node_index;
       } catch (int num) {
-        std::cout << "The data provided exceedes the number of nodes expected for the layer\n";
+        std::cout
+            << "The data provided exceedes the number of nodes expected for the layer\n";
       }
     }
   }
@@ -123,7 +125,8 @@ namespace nnhep {
       }
       m_nodes[i] = value;
     } catch (...) {
-      std::cout << "The index " << i << " is larger than the number of nodes in the layer\n";
+      std::cout << "The index " << i
+                << " is larger than the number of nodes in the layer\n";
     }
   }
 

diff --git a/src/nnhep/headers/Network.hpp b/src/nnhep/headers/Network.hpp
@@ -102,7 +102,9 @@ namespace nnhep {
     /// @param weight_matrix The weight matrix to use
     /// @param bias_vector The bias vector to use
     /// @return The values of the next layer
-    std::vector<T> forward_propatation(shared<Layer<T>>, shared<Matrix<W>>, shared<std::vector<W>>);
+    std::vector<T> forward_propatation(shared<Layer<T>>,
+                                       shared<Matrix<W>>,
+                                       shared<std::vector<W>>);
     /// @brief Forward propagate the values of the network
     ///
     /// @details This function is used to forward propagate the values of the
@@ -185,7 +187,8 @@ namespace nnhep {
         m_bias(n_layers - 1) {
     for (int i{}; i < n_layers - 1; ++i) {
       m_layers[i] = std::make_shared<Layer<T>>(nodes_per_layer[i]);
-      m_weights[i] = std::make_shared<Matrix<W>>(nodes_per_layer[i + 1], nodes_per_layer[i]);
+      m_weights[i] =
+          std::make_shared<Matrix<W>>(nodes_per_layer[i + 1], nodes_per_layer[i]);
       m_bias[i] = std::make_shared<std::vector<W>>(nodes_per_layer[i + 1]);
 
       // Generate random weight matrices
@@ -231,7 +234,8 @@ namespace nnhep {
             typename Activator,
             template <typename E, typename LW, template <typename K> typename Act>
             typename Loss>
-  const shared<Matrix<W>> Network<T, W, Activator, Loss>::weight_matrix(int layer_id) const {
+  const shared<Matrix<W>> Network<T, W, Activator, Loss>::weight_matrix(
+      int layer_id) const {
     return m_weights[layer_id];
   }
 
@@ -251,7 +255,8 @@ namespace nnhep {
             typename Activator,
             template <typename E, typename LW, template <typename K> typename Act>
             typename Loss>
-  void Network<T, W, Activator, Loss>::set_matrix_data(int layer_id, Matrix<W> weight_matrix) {
+  void Network<T, W, Activator, Loss>::set_matrix_data(int layer_id,
+                                                       Matrix<W> weight_matrix) {
     m_weights[layer_id] = std::make_shared<Matrix<W>>(weight_matrix);
   }
 
@@ -261,7 +266,8 @@ namespace nnhep {
             typename Activator,
             template <typename E, typename LW, template <typename K> typename Act>
             typename Loss>
-  void Network<T, W, Activator, Loss>::set_matrix_data(int layer_id, shared<Matrix<W>> weight_matrix_ptr) {
+  void Network<T, W, Activator, Loss>::set_matrix_data(
+      int layer_id, shared<Matrix<W>> weight_matrix_ptr) {
     m_weights[layer_id] = weight_matrix_ptr;
   }
 
@@ -271,7 +277,8 @@ namespace nnhep {
             typename Activator,
             template <typename E, typename LW, template <typename K> typename Act>
             typename Loss>
-  void Network<T, W, Activator, Loss>::set_bias_data(int layer_id, std::vector<W> bias_vector) {
+  void Network<T, W, Activator, Loss>::set_bias_data(int layer_id,
+                                                     std::vector<W> bias_vector) {
     m_bias[layer_id] = std::make_shared<std::vector<W>>(bias_vector);
   }
 
@@ -281,7 +288,8 @@ namespace nnhep {
             typename Activator,
             template <typename E, typename LW, template <typename K> typename Act>
             typename Loss>
-  void Network<T, W, Activator, Loss>::set_bias_data(int layer_id, shared<std::vector<W>> bias_vector_ptr) {
+  void Network<T, W, Activator, Loss>::set_bias_data(
+      int layer_id, shared<std::vector<W>> bias_vector_ptr) {
     m_bias[layer_id] = bias_vector_ptr;
   }
 
@@ -291,9 +299,10 @@ namespace nnhep {
             typename Activator,
             template <typename E, typename LW, template <typename K> typename Act>
             typename Loss>
-  std::vector<T> Network<T, W, Activator, Loss>::forward_propatation(shared<Layer<T>> layer,
-                                                                     shared<Matrix<W>> weight_matrix,
-                                                                     shared<std::vector<W>> bias_vector) {
+  std::vector<T> Network<T, W, Activator, Loss>::forward_propatation(
+      shared<Layer<T>> layer,
+      shared<Matrix<W>> weight_matrix,
+      shared<std::vector<W>> bias_vector) {
     std::vector<W> next_layer_nodes{*weight_matrix * layer->nodes() + *bias_vector};
 
     return Activator<T>()(next_layer_nodes);
@@ -307,7 +316,8 @@ namespace nnhep {
             typename Loss>
   void Network<T, W, Activator, Loss>::forward_propatation() {
     for (int i{}; i < n_layers - 1; ++i) {
-      std::vector<T> new_layer_data{forward_propatation(m_layers[i], m_weights[i], m_bias[i])};
+      std::vector<T> new_layer_data{
+          forward_propatation(m_layers[i], m_weights[i], m_bias[i])};
       m_layers[i + 1]->set_node_data(new_layer_data);
     }
   }
@@ -336,7 +346,8 @@ namespace nnhep {
             template <typename E, typename LW, template <typename K> typename Act>
             typename Loss>
   template <typename U>
-  void Network<T, W, Activator, Loss>::back_propagation(double eta, const std::vector<U>& target) {
+  void Network<T, W, Activator, Loss>::back_propagation(double eta,
+                                                        const std::vector<U>& target) {
     for (int layer_id{n_layers - 2}; layer_id >= 0; --layer_id) {
       back_propagation(target, layer_id, eta);
     }
@@ -395,7 +406,8 @@ namespace nnhep {
         bias.push_back(std::stod(value));
       }
 
-      m_weights[i] = std::make_shared<Matrix<W>>(m_weights[i]->nrows(), m_weights[i]->ncols(), weights);
+      m_weights[i] = std::make_shared<Matrix<W>>(
+          m_weights[i]->nrows(), m_weights[i]->ncols(), weights);
       m_bias[i] = std::make_shared<std::vector<W>>(bias);
     }
   }

diff --git a/test/cuda/MatrixTest/KernelTest/matrix.cu b/test/cuda/MatrixTest/KernelTest/matrix.cu
@@ -9,7 +9,10 @@
 #define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
 #include "doctest.h"
 
-void verify_result(const std::vector<int> &a, const std::vector<int> &b, const std::vector<int> &c, int N) {
+void verify_result(const std::vector<int> &a,
+                   const std::vector<int> &b,
+                   const std::vector<int> &c,
+                   int N) {
   for (int i{}; i < N; ++i) {
     for (int j{}; j < N; ++j) {
       int tmp{};
@@ -25,8 +28,12 @@ void verify_result(const std::vector<int> &a, const std::vector<int> &b, const s
   std::cout << "Success\n";
 }
 
-void verify_result(
-    const std::vector<int> &a, const std::vector<int> &b, const std::vector<int> &c, int N, int K, int M) {
+void verify_result(const std::vector<int> &a,
+                   const std::vector<int> &b,
+                   const std::vector<int> &c,
+                   int N,
+                   int K,
+                   int M) {
   for (int i{}; i < N; ++i) {
     for (int j{}; j < M; ++j) {
       int tmp{};

diff --git a/test/serial/ActivatorsTest/Activators.cc b/test/serial/ActivatorsTest/Activators.cc
@@ -34,7 +34,8 @@ TEST_CASE("Test the Elu functor") {
   CHECK(e(0.) == 0.);
   CHECK(e(std::numeric_limits<double>::max()) == std::numeric_limits<double>::max());
   CHECK(e(-1) == 0.5 * (std::expm1(-1)));
-  CHECK(e(-std::numeric_limits<double>::max()) == 0.5 * (std::expm1(-std::numeric_limits<double>::max())));
+  CHECK(e(-std::numeric_limits<double>::max()) ==
+        0.5 * (std::expm1(-std::numeric_limits<double>::max())));
 }
 
 TEST_CASE("Test the Leaky Elu functor") {
@@ -43,6 +44,7 @@ TEST_CASE("Test the Leaky Elu functor") {
   CHECK(le(0.) == 0.);
   CHECK(le(1.) == 1.);
   CHECK(le(std::numeric_limits<double>::max()) == std::numeric_limits<double>::max());
-  CHECK(le(-std::numeric_limits<double>::max()) == -0.1 * std::numeric_limits<double>::max());
+  CHECK(le(-std::numeric_limits<double>::max()) ==
+        -0.1 * std::numeric_limits<double>::max());
   CHECK(le(-1) == -0.1);
 }