have a totally functionning forward pass

README.md

@@ -1,6 +1,6 @@
 # Tipousi - a tiny and fast deep learning framework from scratch in C++
 
-[![Tipous Build Status](https://github.com/fm94/Tipousi/actions/workflows/cmake-multi-platform.yml/badge.svg?branch=master)](https://github.com/fm94/Tipousi/actions/workflows/cmake-multi-platform.yml)
+[![Tipousi Build Status](https://github.com/fm94/Tipousi/actions/workflows/cmake-multi-platform.yml/badge.svg?branch=master)](https://github.com/fm94/Tipousi/actions/workflows/cmake-multi-platform.yml)
 
 This is a WIP project that implements an entire deep learning framework from scratch in C++.</br>
 The goal is to implement as many layers and modules as possible and have a python interface at the end.</br>

include/graph/sequential.hpp

@@ -18,14 +18,17 @@ namespace Tipousi
                 // travers all nodes in backward pass
                 // and delete all of them sequentially
                 Node *current_node = m_output_node;
-                bool  all_cleaned  = false;
-                while (!all_cleaned)
+                while (true)
                 {
-                    // TODO : hacky approch deleting only first node -> should
-                    // be recursive
-                    Node *next_cleaned = current_node->get_inputs()[0];
+                    // TODO : hacky approch deleting only first node
+                    // -> should be recursive
+                    auto input_nodes = current_node->get_inputs();
+                    if (input_nodes.size() == 0 || !input_nodes[0])
+                    {
+                        break;
+                    }
                     delete current_node;
-                    current_node = next_cleaned;
+                    current_node = input_nodes[0];
                 }
             }
 

src/activation/softmax.cpp

@@ -10,8 +10,7 @@ namespace Tipousi
         {
             Eigen::MatrixXf expX    = in.array().exp();
             Eigen::VectorXf sumExpX = expX.rowwise().sum();
-            out =
-                (expX.array().rowwise() / sumExpX.transpose().array()).matrix();
+            out = (expX.array().colwise() / sumExpX.array()).matrix();
         }
 
         void Softmax::backward(const Eigen::MatrixXf &dout,

src/graph/sequential.cpp

@@ -16,21 +16,22 @@ namespace Tipousi
             // while keeping the original data intact
             Eigen::MatrixXf data_copy    = in;
             Node           *current_node = m_input_node;
-            bool            is_finished  = false;
-            while (!is_finished)
+            // continue until no more nodes
+            while (true)
             {
                 if (current_node)
                 {
                     // TODO hacky approachs: always take number 0
                     auto output_nodes = current_node->get_outputs();
                     if (output_nodes.size() == 0 || !output_nodes[0])
                     {
-                        is_finished = true;
+                        break;
                     }
                     current_node->forward(data_copy);
                     current_node = output_nodes[0];
                 }
             }
+            out = data_copy;
         }
 
         void Sequential::backward()

tests/main.cpp

@@ -4,6 +4,8 @@
 #include "graph/sequential.hpp"
 #include "layer/dense.hpp"
 #include "loss/mse.hpp"
+#include <chrono>
+#include <iostream>
 #include <memory>
 
 using namespace Tipousi;
@@ -14,12 +16,15 @@ using namespace Loss;
 
 void test_create_net()
 {
+    int n_features{2};
+    int n_labels{2};
+
     // create layer nodes
     // these are raw ptrs and ownership will go to the graph,
     // it is responsable for cleaning them!
-    Node *node1 = Node::create<Dense>(5, 32);
+    Node *node1 = Node::create<Dense>(n_features, 32);
     Node *node2 = Node::create<ReLU>();
-    Node *node3 = Node::create<Dense>(32, 1);
+    Node *node3 = Node::create<Dense>(32, n_labels);
     Node *node4 = Node::create<Softmax>();
 
     // build the dependencies
@@ -32,13 +37,21 @@ void test_create_net()
 
     // test inference
     int  n_samples{32};
-    int  n_features{2};
-    int  n_labels{1};
     auto features = Eigen::MatrixXf::Random(n_samples, n_features);
     auto labels   = Eigen::MatrixXf(n_samples, n_labels);
-    // forward pass
+
+    // forward pass with time measurement
     Eigen::MatrixXf preds;
+    auto            start = std::chrono::high_resolution_clock::now();
     net.forward(features, preds);
+    auto end = std::chrono::high_resolution_clock::now();
+    auto duration =
+        std::chrono::duration_cast<std::chrono::microseconds>(end - start)
+            .count();
+
+    std::cout << "Forward pass execution time: " << duration << " microseconds"
+              << std::endl;
+
     // backward pass
     net.backward();
 }