Refactored graph creation to provide cleaner interface, updated unit tests

Author: RobBa

.github/workflows/ci.yml

@@ -11,7 +11,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        gcc-version: [12.3]
+        gcc-version: [13]
         cmake-version: ['3.31.3']
       fail-fast: true
 

src/backend/computational_graph/add_node.cpp

@@ -17,5 +17,5 @@ using namespace graph;
 vector< shared_ptr<Tensor> > AddNode::backward(const Tensor& upstreamGrad) {
   assert(!upstreamGrad.getRequiresGrad());
   auto res = make_shared<Tensor>(upstreamGrad.createDeepCopy());
-  return {res, res}; // TODO: make sure that this works as intended
+  return {res, res};
 }

src/backend/computational_graph/add_node.h

@@ -16,7 +16,8 @@
 namespace graph {
   class AddNode final : public GraphNode {  
     public:
-      explicit AddNode(Tensor* t1, Tensor* t2) : GraphNode({t1, t2}) {}
+      explicit AddNode(std::shared_ptr<Tensor> t1, std::shared_ptr<Tensor> t2) 
+        : GraphNode({std::move(t1), std::move(t2)}) {}
 
       AddNode(const AddNode& other) = delete;
       AddNode& operator=(const AddNode& other) = delete;

src/backend/computational_graph/elementwise_mul_node.h

@@ -16,7 +16,8 @@
 namespace graph {
   class ElementwiseMulNode final : public GraphNode {
     public:
-      explicit ElementwiseMulNode(Tensor* t1, Tensor* t2) : GraphNode({t1, t2}) {}
+      explicit ElementwiseMulNode(std::shared_ptr<Tensor> t1, std::shared_ptr<Tensor> t2) 
+        : GraphNode({std::move(t1), std::move(t2)}) {}
 
       ElementwiseMulNode(const ElementwiseMulNode& other) = delete;
       ElementwiseMulNode& operator=(const ElementwiseMulNode& other) = delete;

src/backend/computational_graph/graph_creation.cpp

@@ -0,0 +1,90 @@
+/**
+ * @file graph_creation.cpp
+ * @author Robert Baumgartner (r.baumgartner-1@tudelft.nl)
+ * @brief 
+ * @version 0.1
+ * @date 2026-02-17
+ * 
+ * @copyright Copyright (c) 2026
+ * 
+ */
+
+#include "graph_creation.h"
+
+#include "add_node.h"
+#include "matmul_node.h"
+#include "elementwise_mul_node.h"
+#include "scalar_op_nodes.h"
+
+using namespace std;
+
+shared_ptr<Tensor> graph::mul(const shared_ptr<Tensor> left, const shared_ptr<Tensor> right) {
+  auto res = make_shared<Tensor>((*left) * (*right));
+  if(left->getRequiresGrad() || right->getRequiresGrad()){
+    assert(res->getRequiresGrad());
+    res->setCgNode(make_shared<graph::ElementwiseMulNode>(left, right));
+  }
+  return res;
+}
+
+shared_ptr<Tensor> graph::add(const shared_ptr<Tensor> left, const shared_ptr<Tensor> right) {
+  auto res = make_shared<Tensor>(*left + *right);
+  if(left->getRequiresGrad() || right->getRequiresGrad()){
+    assert(res->getRequiresGrad());
+    res->setCgNode(make_shared<graph::AddNode>(left, right));
+  }
+  return res;
+}
+
+shared_ptr<Tensor> graph::matmul(const shared_ptr<Tensor> left, const shared_ptr<Tensor> right) {
+  auto res = make_shared<Tensor>(left->matmul(*right));
+  if(left->getRequiresGrad() || right->getRequiresGrad()){
+    assert(res->getRequiresGrad());
+    res->setCgNode(make_shared<graph::MatMulNode>(left, right));
+  }
+  return res;
+}
+
+shared_ptr<Tensor> graph::mul(const shared_ptr<Tensor> t, ftype scalar) {
+  auto res = make_shared<Tensor>((*t) * scalar);
+  if(t->getRequiresGrad()){
+    assert(res->getRequiresGrad());
+    res->setCgNode(std::make_shared<graph::ScalarMulNode>(t, scalar));
+  }
+  return res;
+}
+
+shared_ptr<Tensor> graph::mul(ftype scalar, const shared_ptr<Tensor> t) {
+  return graph::mul(t, scalar);
+}
+
+shared_ptr<Tensor> graph::add(const shared_ptr<Tensor> t, ftype scalar) {
+  auto res = make_shared<Tensor>((*t) + scalar);
+  if(t->getRequiresGrad()){
+    assert(res->getRequiresGrad());
+    res->setCgNode(std::make_shared<graph::ScalarAddNode>(t));
+  }
+  return res;
+}
+
+shared_ptr<Tensor> graph::add(ftype scalar, const shared_ptr<Tensor> t) {
+  return graph::add(t, scalar);
+}
+
+shared_ptr<Tensor> graph::sub(const shared_ptr<Tensor> t, ftype scalar) {
+  auto res = make_shared<Tensor>((*t) - scalar);
+  if(t->getRequiresGrad()){
+    assert(res->getRequiresGrad());
+    res->setCgNode(std::make_shared<graph::ScalarAddNode>(t));
+  }
+  return res;
+}
+
+shared_ptr<Tensor> graph::div(const shared_ptr<Tensor> t, ftype scalar) {
+  auto res = make_shared<Tensor>((*t) / scalar);
+  if(t->getRequiresGrad()){
+    assert(res->getRequiresGrad());
+    res->setCgNode(std::make_shared<graph::ScalarMulNode>(t, 1 / scalar));
+  }
+  return res;
+}

src/backend/computational_graph/graph_creation.h

@@ -0,0 +1,34 @@
+/**
+ * @file graph_creation.h
+ * @author Robert Baumgartner (r.baumgartner-1@tudelft.nl)
+ * @brief Tensor operations that actually create the computational graph.
+ * @version 0.1
+ * @date 2026-02-17
+ * 
+ * @copyright Copyright (c) 2026
+ * 
+ */
+
+#pragma once
+
+#include "data_modeling/tensor.h"
+
+#include <memory>
+
+namespace graph {
+  std::shared_ptr<Tensor> mul(const std::shared_ptr<Tensor> left, const std::shared_ptr<Tensor> right);
+
+  std::shared_ptr<Tensor> add(const std::shared_ptr<Tensor> left, const std::shared_ptr<Tensor> right);
+
+  std::shared_ptr<Tensor> matmul(const std::shared_ptr<Tensor> left, const std::shared_ptr<Tensor> right);
+
+  std::shared_ptr<Tensor> mul(const std::shared_ptr<Tensor> left, ftype scalar); 
+  std::shared_ptr<Tensor> mul(ftype scalar, const std::shared_ptr<Tensor> left); 
+
+  std::shared_ptr<Tensor> add(const std::shared_ptr<Tensor> left, ftype scalar);    
+  std::shared_ptr<Tensor> add(ftype scalar, const std::shared_ptr<Tensor> left);
+
+  std::shared_ptr<Tensor> sub(const std::shared_ptr<Tensor> left, ftype scalar);
+  std::shared_ptr<Tensor> div(const std::shared_ptr<Tensor> left, ftype scalar);  
+}
+ 

src/backend/computational_graph/graph_node.h

@@ -21,8 +21,8 @@
 namespace graph {
   class GraphNode {
     protected:
-      std::vector<Tensor*> parents;
-      explicit GraphNode(std::vector<Tensor*> parents) : parents{std::move(parents)}{}
+      std::vector< std::shared_ptr<Tensor> > parents;
+      explicit GraphNode(std::vector< std::shared_ptr<Tensor> > parents) : parents{std::move(parents)}{}
 
     public:
       virtual std::vector<std::shared_ptr<Tensor>> backward(const Tensor& upstreamGrad) = 0;

src/backend/computational_graph/matmul_node.h

@@ -18,7 +18,8 @@
 namespace graph {
   class MatMulNode final : public GraphNode {
     public:
-      explicit MatMulNode(Tensor* t1, Tensor* t2): GraphNode({t1, t2}) {}
+      explicit MatMulNode(std::shared_ptr<Tensor> t1, std::shared_ptr<Tensor> t2) 
+        : GraphNode({std::move(t1), std::move(t2)}) {}
 
       MatMulNode(const MatMulNode& other) = delete;
       MatMulNode& operator=(const MatMulNode& other) = delete;

src/backend/computational_graph/relu_node.h

@@ -18,7 +18,8 @@
 namespace graph {
   class ReLuNode final : public GraphNode {
     public:
-      explicit ReLuNode(Tensor* t): GraphNode({t}) {}
+      explicit ReLuNode(std::shared_ptr<Tensor> t) 
+        : GraphNode({std::move(t)}) {}
 
       ReLuNode(const ReLuNode& other) = delete;
       ReLuNode& operator=(const ReLuNode& other) = delete;

src/backend/computational_graph/scalar_op_nodes.h

@@ -16,7 +16,8 @@
 namespace graph {
   class ScalarAddNode final : public GraphNode {  
     public:
-      explicit ScalarAddNode(Tensor* t) : GraphNode({t}) {}
+      explicit ScalarAddNode(std::shared_ptr<Tensor> t) 
+        : GraphNode({std::move(t)}) {}
 
       ScalarAddNode(const ScalarAddNode& other) = delete;
       ScalarAddNode& operator=(const ScalarAddNode& other) = delete;
@@ -34,7 +35,8 @@ namespace graph {
       const ftype factor;
 
     public:
-      explicit ScalarMulNode(Tensor* t, const ftype factor) : GraphNode({t}), factor{factor} {}
+      explicit ScalarMulNode(std::shared_ptr<Tensor> t, ftype factor) 
+        : GraphNode({std::move(t)}), factor{factor} {}
 
       ScalarMulNode(const ScalarMulNode& other) = delete;
       ScalarMulNode& operator=(const ScalarMulNode& other) = delete;