Resnet +Fix Shared Ptr Error

include/ml_lib/models/neural-network-ff.h

@@ -11,7 +11,7 @@ class NeuralNetworkFF : public GradientModel {
         Matrix last_output;
 
     public:
-        NeuralNetworkFF(int input_dim, LossFunction* loss, Optimizer* opt, Regularizer* reg);
+        NeuralNetworkFF(int input_dim, std::unique_ptr<LossFunction> loss, std::unique_ptr<Optimizer> opt, std::unique_ptr<Regularizer> reg);
 
         void addLayer(int input_dim, int output_dim, ACTIVATION_FUNC act);
 

include/ml_lib/models/neural-network-resnet.h

@@ -0,0 +1,22 @@
+#pragma once
+#include "../math/matrix.h"
+#include "gradient-model.h"
+#include "../core/neural-network-layer.h"
+
+class NeuralNetworkResNet : public GradientModel {
+    private:
+        std::vector<NeuralNetworkLayer> layers;
+
+        Matrix last_input;
+        Matrix last_output;
+        int skips = 2; // Number of layers after which to add a skip connection
+
+    public:
+        NeuralNetworkResNet(int input_dim, std::unique_ptr<LossFunction> loss, std::unique_ptr<Optimizer> opt, std::unique_ptr<Regularizer> reg, int skips = 2);
+
+        void addLayer(int input_dim, int output_dim, ACTIVATION_FUNC act);
+
+        Matrix forward(const Matrix& X) override;
+        void backward(const Matrix& y_true) override;
+        void update() override;
+};

include/ml_lib/models/perceptron.h

@@ -17,7 +17,7 @@ class Perceptron : public GradientModel {
         Matrix grad_b;
 
     public:
-        Perceptron(int input_dim, LossFunction* loss, Optimizer* opt, Regularizer* reg);
+        Perceptron(int input_dim, std::unique_ptr<LossFunction> loss, std::unique_ptr<Optimizer> opt, std::unique_ptr<Regularizer> reg);
 
         Matrix forward(const Matrix& X) override;
         void backward(const Matrix& y_true) override;

source/models/neural-network-ff-resnet.cpp

@@ -0,0 +1,51 @@
+#include "neural-network-resnet.h"
+#include "neural-network-layer.h"
+#include <algorithm>
+
+NeuralNetworkResNet::NeuralNetworkResNet(int input_dim, std::unique_ptr<LossFunction> loss, std::unique_ptr<Optimizer> opt, std::unique_ptr<Regularizer> reg, int skips)
+    : GradientModel(std::move(loss), std::move(opt), std::move(reg)), skips(skips)
+{}
+
+void NeuralNetworkResNet::addLayer(int input_dim, int output_dim, ACTIVATION_FUNC act)
+{
+    this->layers.push_back(NeuralNetworkLayer(input_dim, output_dim, act));
+}
+
+Matrix NeuralNetworkResNet::forward(const Matrix &X)
+{
+    last_input = X;
+    Matrix residual = X;
+
+    for (int i = 0; i < layers.size(); i++) {
+        last_input = layers[i].forward(last_input);
+
+        if ((i + 1) % skips == 0 && last_input.rows() == residual.rows() && last_input.cols() == residual.cols()) {
+            last_input = last_input + residual;
+            residual = last_input;
+        }
+    }
+    last_output = last_input;
+
+    return last_output;
+}
+
+void NeuralNetworkResNet::backward(const Matrix &y_true)
+{
+    Matrix last_gradient = loss_func->gradient(last_output, y_true);
+    for (int i = layers.size() - 1; i >= 0; i--) {
+        Matrix layer_grad = layers[i].backward(last_gradient);
+
+        if ((i + 1) % skips == 0) {
+            last_gradient = layer_grad + last_gradient;
+        } else {
+            last_gradient = layer_grad;
+        }
+    }
+}
+
+void NeuralNetworkResNet::update()
+{
+    for (auto& layer : layers) {
+        layer.update(optimizer.get());
+    }
+}

source/models/neural-network-ff.cpp

@@ -2,8 +2,8 @@
 #include "neural-network-layer.h"
 #include <algorithm>
 
-NeuralNetworkFF::NeuralNetworkFF(int input_dim, LossFunction *loss, Optimizer *opt, Regularizer *reg)
-    : GradientModel(loss, opt, reg)
+NeuralNetworkFF::NeuralNetworkFF(int input_dim, std::unique_ptr<LossFunction> loss, std::unique_ptr<Optimizer> opt, std::unique_ptr<Regularizer> reg)
+    : GradientModel(std::move(loss), std::move(opt), std::move(reg))
 {}
 
 void NeuralNetworkFF::addLayer(int input_dim, int output_dim, ACTIVATION_FUNC act)

source/models/perceptron.cpp

@@ -1,8 +1,8 @@
 #include "ml_lib/models/perceptron.h"
 #include <cmath>
 
-Perceptron::Perceptron(int input_dim, LossFunction* loss, Optimizer* opt, Regularizer* reg)
-    : GradientModel(loss, opt, reg), weights(input_dim, 1, 0.01), bias(1, 1, 0.0),
+Perceptron::Perceptron(int input_dim, std::unique_ptr<LossFunction> loss, std::unique_ptr<Optimizer> opt, std::unique_ptr<Regularizer> reg)
+    : GradientModel(std::move(loss), std::move(opt), std::move(reg)), weights(input_dim, 1, 0.01), bias(1, 1, 0.0),
       grad_w(input_dim, 1, 0.0), grad_b(1, 1, 0.0) {}
 
 Matrix Perceptron::forward(const Matrix &X)