COMPMID-1035 - Add ResneXt50 as a graph example

Change-Id: I42f0e7dab38e45b5eecfe6858eaecee8939c8585
Reviewed-on: https://eu-gerrit-1.euhpc.arm.com/129291
Reviewed-by: Georgios Pinitas <georgios.pinitas@arm.com>
Reviewed-by: Anthony Barbier <anthony.barbier@arm.com>
Tested-by: Jenkins <bsgcomp@arm.com>

5 files changed, 65 insertions, 24 deletions

diff --git a/src/graph/GraphBuilder.cpp b/src/graph/GraphBuilder.cpp
index df94d0b169..4c5d30a33f 100644
--- a/src/graph/GraphBuilder.cpp
+++ b/src/graph/GraphBuilder.cpp
@@ -399,6 +399,35 @@ NodeID GraphBuilder::add_reshape_node(Graph &g, NodeParams params, NodeIdxPair i
     return create_simple_single_input_output_node<ReshapeLayerNode>(g, params, input, shape);
 }
 
+NodeID GraphBuilder::add_scale_layer(Graph &g, const NodeParams &params, NodeIdxPair input, ITensorAccessorUPtr mul_accessor, ITensorAccessorUPtr add_accessor)
+{
+    CHECK_NODEIDX_PAIR(input, g);
+
+    // Get input tensor descriptor
+    const TensorDescriptor input_tensor_desc = get_tensor_descriptor(g, g.node(input.node_id)->outputs()[0]);
+
+    // Create mul node
+    TensorDescriptor mul_desc = input_tensor_desc;
+    const size_t     C        = input_tensor_desc.shape[get_dimension_idx(mul_desc, DataLayoutDimension::CHANNEL)];
+    mul_desc.shape.set(get_dimension_idx(input_tensor_desc, DataLayoutDimension::WIDTH), 1);
+    mul_desc.shape.set(get_dimension_idx(input_tensor_desc, DataLayoutDimension::HEIGHT), 1);
+    mul_desc.shape.set(get_dimension_idx(input_tensor_desc, DataLayoutDimension::CHANNEL), C);
+    NodeID      mul_const_nid   = add_const_node_with_name(g, params, "Mul", mul_desc, std::move(mul_accessor));
+    NodeIdxPair mul_const_nidxp = { mul_const_nid, 0 };
+
+    // Create add node
+    TensorDescriptor add_desc        = mul_desc;
+    NodeID           add_const_nid   = add_const_node_with_name(g, params, "Add", add_desc, std::move(add_accessor));
+    NodeIdxPair      add_const_nidxp = { add_const_nid, 0 };
+
+    // Create node and connect
+    NodeID      mul_node      = GraphBuilder::add_elementwise_node(g, params, input, mul_const_nidxp, EltwiseOperation::MUL);
+    NodeIdxPair mulnode_nidxp = { mul_node, 0 };
+    NodeID      add_node      = GraphBuilder::add_elementwise_node(g, params, mulnode_nidxp, add_const_nidxp, EltwiseOperation::ADD);
+
+    return add_node;
+}
+
 NodeID GraphBuilder::add_softmax_node(Graph &g, NodeParams params, NodeIdxPair input, float beta)
 {
     return create_simple_single_input_output_node<SoftmaxLayerNode>(g, params, input, beta);
diff --git a/src/graph/backends/CL/CLFunctionsFactory.cpp b/src/graph/backends/CL/CLFunctionsFactory.cpp
index 4626cb5781..ac04f1063c 100644
--- a/src/graph/backends/CL/CLFunctionsFactory.cpp
+++ b/src/graph/backends/CL/CLFunctionsFactory.cpp
@@ -313,10 +313,11 @@ std::unique_ptr<IFunction> create_eltwise_layer(EltwiseLayerNode &node)
     ARM_COMPUTE_ERROR_ON(node.num_outputs() != 1);
 
     // Extract IO and info
-    ICLTensor             *input1     = get_backing_tensor(node.input(0));
-    ICLTensor             *input2     = get_backing_tensor(node.input(1));
-    ICLTensor             *output     = get_backing_tensor(node.output(0));
-    const EltwiseOperation eltwise_op = node.eltwise_operation();
+    ICLTensor             *input1         = get_backing_tensor(node.input(0));
+    ICLTensor             *input2         = get_backing_tensor(node.input(1));
+    ICLTensor             *output         = get_backing_tensor(node.output(0));
+    const EltwiseOperation eltwise_op     = node.eltwise_operation();
+    const ConvertPolicy    convert_policy = node.convert_policy();
     ARM_COMPUTE_ERROR_ON(input1 == nullptr);
     ARM_COMPUTE_ERROR_ON(input2 == nullptr);
     ARM_COMPUTE_ERROR_ON(output == nullptr);
@@ -327,18 +328,18 @@ std::unique_ptr<IFunction> create_eltwise_layer(EltwiseLayerNode &node)
     {
         std::tie(func, func_name) = create_named_function<CLArithmeticAddition>(std::string("CLArithmeticAddition"),
                                                                                 input1, input2, output,
-                                                                                ConvertPolicy::SATURATE);
+                                                                                convert_policy);
     }
     else if(eltwise_op == EltwiseOperation::SUB)
     {
         std::tie(func, func_name) = create_named_function<CLArithmeticSubtraction>(
-                                        std::string("CLArithmeticSubtraction"), input1, input2, output, ConvertPolicy::SATURATE);
+                                        std::string("CLArithmeticSubtraction"), input1, input2, output, convert_policy);
     }
     else if(eltwise_op == EltwiseOperation::MUL)
     {
         std::tie(func, func_name) = create_named_function<CLPixelWiseMultiplication>(
-                                        std::string("CLPixelWiseMultiplication"), input1, input2, output, 1.f, ConvertPolicy::SATURATE,
-                                        RoundingPolicy::TO_NEAREST_EVEN);
+                                        std::string("CLPixelWiseMultiplication"), input1, input2, output, 1.f, convert_policy,
+                                        node.rounding_policy());
     }
     else
     {
diff --git a/src/graph/backends/GLES/GCFunctionsFactory.cpp b/src/graph/backends/GLES/GCFunctionsFactory.cpp
index d3c5737e68..d53daf1109 100644
--- a/src/graph/backends/GLES/GCFunctionsFactory.cpp
+++ b/src/graph/backends/GLES/GCFunctionsFactory.cpp
@@ -301,10 +301,11 @@ std::unique_ptr<IFunction> create_eltwise_layer(EltwiseLayerNode &node)
     ARM_COMPUTE_ERROR_ON(node.num_outputs() != 1);
 
     // Extract IO and info
-    IGCTensor             *input1     = get_backing_tensor(node.input(0));
-    IGCTensor             *input2     = get_backing_tensor(node.input(1));
-    IGCTensor             *output     = get_backing_tensor(node.output(0));
-    const EltwiseOperation eltwise_op = node.eltwise_operation();
+    IGCTensor             *input1         = get_backing_tensor(node.input(0));
+    IGCTensor             *input2         = get_backing_tensor(node.input(1));
+    IGCTensor             *output         = get_backing_tensor(node.output(0));
+    const EltwiseOperation eltwise_op     = node.eltwise_operation();
+    const ConvertPolicy    convert_policy = node.convert_policy();
     ARM_COMPUTE_ERROR_ON(input1 == nullptr);
     ARM_COMPUTE_ERROR_ON(input2 == nullptr);
     ARM_COMPUTE_ERROR_ON(output == nullptr);
@@ -315,7 +316,7 @@ std::unique_ptr<IFunction> create_eltwise_layer(EltwiseLayerNode &node)
     {
         std::tie(func, func_name) = create_named_function<GCArithmeticAddition>(std::string("GCArithmeticAddition"),
                                                                                 input1, input2, output,
-                                                                                ConvertPolicy::SATURATE);
+                                                                                convert_policy);
     }
     else if(eltwise_op == EltwiseOperation::SUB)
     {
diff --git a/src/graph/backends/NEON/NEFunctionFactory.cpp b/src/graph/backends/NEON/NEFunctionFactory.cpp
index 7a37dfa39d..7f97876e57 100644
--- a/src/graph/backends/NEON/NEFunctionFactory.cpp
+++ b/src/graph/backends/NEON/NEFunctionFactory.cpp
@@ -294,10 +294,11 @@ std::unique_ptr<IFunction> create_eltwise_layer(EltwiseLayerNode &node)
     ARM_COMPUTE_ERROR_ON(node.num_outputs() != 1);
 
     // Extract IO and info
-    ITensor               *input1     = get_backing_tensor(node.input(0));
-    ITensor               *input2     = get_backing_tensor(node.input(1));
-    ITensor               *output     = get_backing_tensor(node.output(0));
-    const EltwiseOperation eltwise_op = node.eltwise_operation();
+    ITensor               *input1         = get_backing_tensor(node.input(0));
+    ITensor               *input2         = get_backing_tensor(node.input(1));
+    ITensor               *output         = get_backing_tensor(node.output(0));
+    const EltwiseOperation eltwise_op     = node.eltwise_operation();
+    const ConvertPolicy    convert_policy = node.convert_policy();
     ARM_COMPUTE_ERROR_ON(input1 == nullptr);
     ARM_COMPUTE_ERROR_ON(input2 == nullptr);
     ARM_COMPUTE_ERROR_ON(output == nullptr);
@@ -307,18 +308,18 @@ std::unique_ptr<IFunction> create_eltwise_layer(EltwiseLayerNode &node)
     if(eltwise_op == EltwiseOperation::ADD)
     {
         std::tie(func, func_name) = create_named_function<NEArithmeticAddition>(std::string("NEArithmeticAddition"),
-                                                                                input1, input2, output, ConvertPolicy::SATURATE);
+                                                                                input1, input2, output, convert_policy);
     }
     else if(eltwise_op == EltwiseOperation::SUB)
     {
         std::tie(func, func_name) = create_named_function<NEArithmeticSubtraction>(std::string("NEArithmeticSubtraction"),
-                                                                                   input1, input2, output, ConvertPolicy::SATURATE);
+                                                                                   input1, input2, output, convert_policy);
     }
     else if(eltwise_op == EltwiseOperation::MUL)
     {
         std::tie(func, func_name) = create_named_function<NEPixelWiseMultiplication>(std::string("NEPixelWiseMultiplication"),
                                                                                      input1, input2, output, 1.f,
-                                                                                     ConvertPolicy::SATURATE, RoundingPolicy::TO_NEAREST_EVEN);
+                                                                                     convert_policy, node.rounding_policy());
     }
     else
     {
diff --git a/src/graph/nodes/EltwiseLayerNode.cpp b/src/graph/nodes/EltwiseLayerNode.cpp
index 6f1e0eecd9..568b882425 100644
--- a/src/graph/nodes/EltwiseLayerNode.cpp
+++ b/src/graph/nodes/EltwiseLayerNode.cpp
@@ -30,8 +30,8 @@ namespace arm_compute
 {
 namespace graph
 {
-EltwiseLayerNode::EltwiseLayerNode(EltwiseOperation op)
-    : _op(op)
+EltwiseLayerNode::EltwiseLayerNode(EltwiseOperation op, ConvertPolicy c_policy, RoundingPolicy r_policy)
+    : _op(op), _convert_policy(c_policy), _rounding_policy(r_policy)
 {
     _input_edges.resize(2, EmptyEdgeID);
     _outputs.resize(1, NullTensorID);
@@ -42,6 +42,16 @@ EltwiseOperation EltwiseLayerNode::eltwise_operation() const
     return _op;
 }
 
+ConvertPolicy EltwiseLayerNode::convert_policy() const
+{
+    return _convert_policy;
+}
+
+RoundingPolicy EltwiseLayerNode::rounding_policy() const
+{
+    return _rounding_policy;
+}
+
 bool EltwiseLayerNode::forward_descriptors()
 {
     if((input_id(0) != NullTensorID) && (output_id(0) != NullTensorID))
@@ -56,8 +66,7 @@ bool EltwiseLayerNode::forward_descriptors()
 
 TensorDescriptor EltwiseLayerNode::configure_output(size_t idx) const
 {
-    ARM_COMPUTE_UNUSED(idx);
-    ARM_COMPUTE_UNUSED(_op);
+    ARM_COMPUTE_UNUSED(idx, _op, _convert_policy, _rounding_policy);
 
     const Tensor *src = input(0);
     ARM_COMPUTE_ERROR_ON(src == nullptr);