autograd engine working

Author: Vansh5632

CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.14)
+cmake_minimum_required(VERSION 3.17)
 
 # Project declaration
 project(TorchScratch
@@ -29,7 +29,19 @@ include_directories(
 )
 
 # Create library target
-add_library(torchscratch src/core/tensor/tensor.cpp src/core/tensor/ops.cpp)
+add_library(torchscratch 
+src/core/tensor/tensor.cpp 
+src/core/tensor/ops.cpp 
+src/core/tensor/tensor_impl.cpp
+src/core/autograd/engine.cpp
+)
+
+set(HEADER
+    include/core/tensor/tensor.h
+    include/core/tensor/ops.h
+    include/core/tensor/tensor_impl.h
+    include/core/autograd/function.h
+    include/core/autograd/variable.h)
 
 # Set include directories for the target
 target_include_directories(torchscratch PUBLIC

include/core/autograd/function.h

@@ -11,58 +11,101 @@
 namespace torchscratch {
 namespace core {
 namespace autograd {
+
+// Forward declaration
 class Variable;
 
+/**
+ * Base class for all autograd functions.
+ * Each subclass implements a particular operation (like Add, MatMul, etc.)
+ * with its forward and backward pass logic.
+ */
 class Function {
 public:
   virtual ~Function() = default;
+
+  // Rule of 5: Allow proper inheritance
   Function() = default;
   Function(const Function&) = default;
   Function& operator=(const Function&) = default;
   Function(Function&&) noexcept = default;
   Function& operator=(Function&&) noexcept = default;
 
+  /**
+   * Apply the forward pass of this function to the inputs.
+   * @param inputs Vector of input tensors
+   * @return Vector of output tensors
+   */
   virtual std::vector<tensor::Tensor> forward(const std::vector<tensor::Tensor>& inputs) = 0;
 
-  virtual std::vector<tensor::Tensor> backward(const std::vector<tensor::Tensor>& grad_outputs) = 0;
+  /**
+   * Apply the backward pass of this function.
+   * @param grad_output Gradient of the loss with respect to the output
+   * @return Vector of gradients with respect to the inputs
+   */
+  virtual std::vector<tensor::Tensor> backward(const std::vector<tensor::Tensor>& grad_output) = 0;
 
+  /**
+   * Get a string representation of this function for debugging.
+   */
   virtual std::string name() const = 0;
 
-  void save_for_backward(const std::vector<tensor::Tensor>& inputs);
+  /**
+   * Save pointers to the input variables for backward pass.
+   * @param inputs Vector of input variables
+   */
+  void save_for_backward(const std::vector<Variable*>& inputs);
 
+  /**
+   * Get the saved input variables.
+   * @return Vector of saved input variables
+   */
   const std::vector<Variable*>& get_saved_variables() const;
 
 private:
   std::vector<Variable*> saved_variables_;
 };
+
+/**
+ * AddFunction implements element-wise addition with broadcasting.
+ */
 class AddFunction : public Function {
 public:
   std::vector<tensor::Tensor> forward(const std::vector<tensor::Tensor>& inputs) override;
-  std::vector<tensor::Tensor> backward(const std::vector<tensor::Tensor>& grad_outputs) override;
+  std::vector<tensor::Tensor> backward(const std::vector<tensor::Tensor>& grad_output) override;
   std::string name() const override { return "AddFunction"; }
 };
+
+/**
+ * MulFunction implements element-wise multiplication.
+ */
 class MulFunction : public Function {
 public:
   std::vector<tensor::Tensor> forward(const std::vector<tensor::Tensor>& inputs) override;
-  std::vector<tensor::Tensor> backward(const std::vector<tensor::Tensor>& grad_outputs) override;
+  std::vector<tensor::Tensor> backward(const std::vector<tensor::Tensor>& grad_output) override;
   std::string name() const override { return "MulFunction"; }
 
 private:
-  tensor::Tensor input1_;
+  tensor::Tensor input1_;  // Save inputs for backward pass
   tensor::Tensor input2_;
 };
+
+/**
+ * MatMulFunction implements matrix multiplication.
+ */
 class MatMulFunction : public Function {
 public:
   std::vector<tensor::Tensor> forward(const std::vector<tensor::Tensor>& inputs) override;
-  std::vector<tensor::Tensor> backward(const std::vector<tensor::Tensor>& grad_outputs) override;
+  std::vector<tensor::Tensor> backward(const std::vector<tensor::Tensor>& grad_output) override;
   std::string name() const override { return "MatMulFunction"; }
 
 private:
-  tensor::Tensor input1_;
+  tensor::Tensor input1_;  // Save inputs for backward pass
   tensor::Tensor input2_;
 };
 
 }  // namespace autograd
 }  // namespace core
 }  // namespace torchscratch
-#endif
+
+#endif  // AUTOGRAD_FUNCTION_H

include/core/tensor/tensor.h

@@ -7,6 +7,8 @@
 #include <stdexcept>
 #include <vector>
 
+#include "core/tensor/tensor_impl.h"
+
 namespace torchscratch {
 namespace core {
 namespace tensor {

include/core/tensor/tensor_impl.h

@@ -0,0 +1,68 @@
+#pragma once
+#ifndef TENSOR_IMPL_H
+#define TENSOR_IMPL_H
+
+#include <cstddef>  // For std::size_t
+#include <cstdint>
+#include <vector>
+
+namespace torchscratch {
+namespace core {
+namespace tensor {
+
+class DType;
+
+/**
+ * Internal implementation for Tensor class.
+ */
+struct TensorImpl {
+  void* data_ = nullptr;          // Raw data pointer
+  std::vector<int64_t> shape_;    // Tensor shape
+  std::vector<int64_t> strides_;  // Strides (bytes between elements)
+  DType* dtype_ = nullptr;        // Placeholder for data type
+  bool is_contiguous_ = true;     // Contiguity flag
+  bool owns_data_ = true;         // Ownership of data
+
+  TensorImpl() = default;
+
+  TensorImpl(const std::vector<int64_t>& shape, DType* dtype);
+
+  // Copy constructor - Create a shallow copy (share data pointer)
+  TensorImpl(const TensorImpl& other);
+
+  // Move constructor
+  TensorImpl(TensorImpl&& other) noexcept;
+
+  // Assignment operators
+  TensorImpl& operator=(const TensorImpl& other);
+  TensorImpl& operator=(TensorImpl&& other) noexcept;
+
+  ~TensorImpl();
+
+  static std::vector<int64_t> compute_strides(const std::vector<int64_t>& shape);
+
+  // Helper method to get element at specified indices
+  template <typename T>
+  T& get(const std::vector<int64_t>& indices) {
+    std::size_t offset = 0;
+    for (std::size_t i = 0; i < indices.size(); ++i) {
+      offset += indices[i] * strides_[i];
+    }
+    return static_cast<T*>(data_)[offset];
+  }
+
+  template <typename T>
+  const T& get(const std::vector<int64_t>& indices) const {
+    std::size_t offset = 0;
+    for (std::size_t i = 0; i < indices.size(); ++i) {
+      offset += indices[i] * strides_[i];
+    }
+    return static_cast<const T*>(data_)[offset];
+  }
+};
+
+}  // namespace tensor
+}  // namespace core
+}  // namespace torchscratch
+
+#endif  // TENSOR_IMPL_H

reports/cppcheck_report.txt

@@ -1,10 +1,14 @@
+Checking /home/vansh5632/sudo/nn/src/core/autograd/engine.cpp ...
+1/4 files checked 44% done
 Checking /home/vansh5632/sudo/nn/src/core/tensor/ops.cpp ...
-1/2 files checked 35% done
+2/4 files checked 63% done
 Checking /home/vansh5632/sudo/nn/src/core/tensor/tensor.cpp ...
-/home/vansh5632/sudo/nn/src/core/tensor/tensor.cpp:95:3: performance: Variable 'impl_' is assigned in constructor body. Consider performing initialization in initialization list. [useInitializationList]
+/home/vansh5632/sudo/nn/src/core/tensor/tensor.cpp:33:3: performance: Variable 'impl_' is assigned in constructor body. Consider performing initialization in initialization list. [useInitializationList]
   impl_ = std::make_unique<TensorImpl>(shape, dtype);
   ^
-/home/vansh5632/sudo/nn/src/core/tensor/tensor.cpp:99:3: performance: Variable 'impl_' is assigned in constructor body. Consider performing initialization in initialization list. [useInitializationList]
+/home/vansh5632/sudo/nn/src/core/tensor/tensor.cpp:37:3: performance: Variable 'impl_' is assigned in constructor body. Consider performing initialization in initialization list. [useInitializationList]
   impl_ = std::make_unique<TensorImpl>(shape, dtype);
   ^
-2/2 files checked 100% done
+3/4 files checked 87% done
+Checking /home/vansh5632/sudo/nn/src/core/tensor/tensor_impl.cpp ...
+4/4 files checked 100% done