Changes

Author: NeiroYT

include/graph/graph.hpp

@@ -75,7 +75,8 @@ class Graph {
   Graph& operator=(Graph&&) noexcept = default;
   ~Graph() = default;
 
-  void clone(Graph& result, Tensor& out, const RuntimeOptions& options) const;
+  void clone(Graph& result, Tensor& out,
+             const RuntimeOptions& options = RuntimeOptions()) const;
 
   void setSplitDistribution(
       std::vector<std::vector<std::pair<int, int>>> split_dist) {

include/layers/ConvLayer.hpp

@@ -36,7 +36,9 @@ class ConvolutionalLayer : public Layer {
   ConvolutionalLayer(size_t step, size_t pads, size_t dilations, Tensor& kernel,
                      Tensor& bias = *std::make_shared<Tensor>(),
                      size_t group = 1, bool useLegacyImpl = false)
-      : Layer(kConvolution), kernel_(&kernel), bias_(&bias) {
+      : Layer(kConvolution),
+        kernel_(std::make_shared<Tensor>(kernel)),
+        bias_(std::make_shared<Tensor>(bias)) {
     stride_ = step;
     pads_ = pads;
     group_ = group;

include/layers/FCLayer.hpp

@@ -17,7 +17,9 @@ class FCLayer : public Layer {
  public:
   FCLayer() : Layer(kFullyConnected), weights_(nullptr), bias_(nullptr) {}
   FCLayer(Tensor& weights, Tensor& bias)
-      : Layer(kFullyConnected), weights_(&weights), bias_(&bias) {}
+      : Layer(kFullyConnected),
+        weights_(std::make_shared<Tensor>(weights)),
+        bias_(std::make_shared<Tensor>(bias)) {}
   FCLayer(std::shared_ptr<Tensor> weights, std::shared_ptr<Tensor> bias)
       : Layer(kFullyConnected), weights_(weights), bias_(bias) {}
   void run(const std::vector<Tensor>& input,

include/layers_oneDNN/ConvLayer.hpp

@@ -28,8 +28,8 @@ class ConvLayerOneDnn : public Layer {
         stride_(stride),
         pads_(pads),
         dilations_(dilations),
-        kernel_(&kernel),
-        bias_(&bias),
+        kernel_(std::make_shared<Tensor>(kernel)),
+        bias_(std::make_shared<Tensor>(bias)),
         group_(group),
         use_legacy_(use_legacy) {}
 

src/graph/graph.cpp

@@ -164,6 +164,11 @@ std::shared_ptr<Layer> layer_based_shared_copy(
           *dynamic_cast<BatchNormalizationLayer*>(layer.get()));
       return std::shared_ptr<Layer>(tmp_layer);
     }
+    case it_lab_ai::kOutput: {
+      OutputLayer* tmp_layer =
+          new OutputLayer(*dynamic_cast<OutputLayer*>(layer.get()));
+      return std::shared_ptr<Layer>(tmp_layer);
+    }
     default: {
       throw std::invalid_argument("No such layer type");
     }

test/graph/test_graph.cpp

@@ -5,15 +5,109 @@
 #include "graph/graph.hpp"
 #include "graph_transformations/graph_transformations.hpp"
 #include "gtest/gtest.h"
+#include "layers/BatchNormalizationLayer.hpp"
+#include "layers/BinaryOpLayer.hpp"
 #include "layers/ConcatLayer.hpp"
+#include "layers/ConvLayer.hpp"
+#include "layers/DropOutLayer.hpp"
 #include "layers/EWLayer.hpp"
 #include "layers/FCLayer.hpp"
+#include "layers/FlattenLayer.hpp"
 #include "layers/InputLayer.hpp"
+#include "layers/MatmulLayer.hpp"
+#include "layers/OutputLayer.hpp"
+#include "layers/PoolingLayer.hpp"
+#include "layers/ReduceLayer.hpp"
+#include "layers/ReshapeLayer.hpp"
+#include "layers/SoftmaxLayer.hpp"
 #include "layers/SplitLayer.hpp"
+#include "layers/Tensor.hpp"
+#include "layers/TransposeLayer.hpp"
+#include "layers_oneDNN/BinaryOpLayer.hpp"
+#include "layers_oneDNN/ConvLayer.hpp"
+#include "layers_oneDNN/EWLayer.hpp"
+#include "layers_oneDNN/PoolingLayer.hpp"
+#include "layers_oneDNN/ReduceLayer.hpp"
 #include "perf/benchmarking.hpp"
 
 using namespace it_lab_ai;
 
+TEST(graph, test_deep_copy) {
+  Graph graph;
+  Graph graph2;
+  Graph graph_c;
+  Graph graph2_c;
+  Tensor input = make_tensor<float>({1.0F, 2.0F}, {2});
+  Tensor output;
+  auto lay1 = std::make_shared<InputLayer>();
+  Shape sh = {2, 2};
+  auto lay2 = std::make_shared<PoolingLayer>(sh, "average");
+  auto lay3 = std::make_shared<EWLayer>();
+  auto lay3_alt = std::make_shared<EwLayerOneDnn>();
+  auto lay4 = std::make_shared<ConvolutionalLayer>();
+  auto lay4_alt = std::make_shared<ConvLayerOneDnn>();
+  auto lay5 = std::make_shared<FCLayer>();
+  auto lay6 = std::make_shared<FlattenLayer>();
+  auto lay7 = std::make_shared<FlattenLayer>();
+  auto lay8 = std::make_shared<DropOutLayer>();
+  auto lay9 = std::make_shared<SplitLayer>(0, 2);
+  auto lay10 = std::make_shared<BinaryOpLayer>();
+  auto lay10_alt = std::make_shared<BinaryOpLayerOneDnn>();
+  auto lay11 = std::make_shared<TransposeLayer>();
+  auto lay12 = std::make_shared<MatmulLayer>();
+  auto lay13 = std::make_shared<ReshapeLayer>();
+  auto lay14 = std::make_shared<SoftmaxLayer>();
+  auto lay15 = std::make_shared<ReduceLayer>();
+  auto lay15_alt = std::make_shared<ReduceLayerOneDnn>();
+  Tensor scale = make_tensor<float>({1.0f}, {1});
+  Tensor bias = make_tensor<float>({0.0f}, {1});
+  Tensor mean = make_tensor<float>({0.0f}, {1});
+  Tensor var = make_tensor<float>({1.0f}, {1});
+  auto lay16 =
+      std::make_shared<BatchNormalizationLayer>(scale, bias, mean, var);
+  auto lay17 = std::make_shared<OutputLayer>();
+  graph.setInput(lay1, input);
+  graph2.setInput(lay1, input);
+  graph.makeConnection(lay1, lay2);
+  graph2.makeConnection(lay1, lay2);
+  graph.makeConnection(lay1, lay3);
+  graph2.makeConnection(lay1, lay3_alt);
+  graph.makeConnection(lay2, lay4);
+  graph2.makeConnection(lay2, lay4_alt);
+  graph.makeConnection(lay2, lay5);
+  graph2.makeConnection(lay2, lay5);
+  graph.makeConnection(lay3, lay6);
+  graph2.makeConnection(lay3, lay6);
+  graph.makeConnection(lay3, lay7);
+  graph2.makeConnection(lay3, lay7);
+  graph.makeConnection(lay4, lay8);
+  graph2.makeConnection(lay4, lay8);
+  graph.makeConnection(lay4, lay9);
+  graph2.makeConnection(lay4, lay9);
+  graph.makeConnection(lay5, lay10);
+  graph2.makeConnection(lay5, lay10_alt);
+  graph.makeConnection(lay5, lay11);
+  graph2.makeConnection(lay5, lay11);
+  graph.makeConnection(lay6, lay12);
+  graph2.makeConnection(lay6, lay12);
+  graph.makeConnection(lay6, lay13);
+  graph2.makeConnection(lay6, lay13);
+  graph.makeConnection(lay7, lay14);
+  graph2.makeConnection(lay7, lay14);
+  graph.makeConnection(lay7, lay15);
+  graph2.makeConnection(lay7, lay15_alt);
+  graph.makeConnection(lay8, lay16);
+  graph2.makeConnection(lay8, lay16);
+  graph.makeConnection(lay8, lay17);
+  graph2.makeConnection(lay8, lay17);
+  graph.setOutput(lay16, output);
+  graph2.setOutput(lay16, output);
+  RuntimeOptions opt;
+  opt.backend = Backend::kOneDnn;
+  ASSERT_NO_THROW(graph.clone(graph_c, output));
+  ASSERT_NO_THROW(graph.clone(graph2_c, output, opt));
+}
+
 TEST(graph, check_connection) {
   const std::vector<float> vec1 = {2.0F, 1.5F, 0.1F, 1.9F, 0.0F, 5.5F};
   Tensor weights = make_tensor<float>(vec1, {3, 2});