GraphBuilder Class Reference

Graph builder class. More...

#include <GraphBuilder.h>

Static Public Member Functions
static NodeID	add_const_node (Graph &g, NodeParams params, const TensorDescriptor &desc, ITensorAccessorUPtr accessor=nullptr)
	Adds a Const node to the graph. More...
static NodeID	add_input_node (Graph &g, NodeParams params, const TensorDescriptor &desc, ITensorAccessorUPtr accessor=nullptr)
	Adds an input layer node to the graph. More...
static NodeID	add_output_node (Graph &g, NodeParams params, NodeIdxPair input, ITensorAccessorUPtr accessor=nullptr)
	Adds an output layer node to the graph. More...
static NodeID	add_activation_node (Graph &g, NodeParams params, NodeIdxPair input, ActivationLayerInfo act_info, const QuantizationInfo &out_quant_info=QuantizationInfo())
	Adds an activation layer node to the graph. More...
static NodeID	add_arg_min_max_node (Graph &g, NodeParams params, NodeIdxPair input, ReductionOperation op, unsigned int axis, DataType out_data_type=DataType::UNKNOWN, const QuantizationInfo &out_quant_info=QuantizationInfo())
	Adds an activation layer node to the graph. More...
static NodeID	add_batch_normalization_node (Graph &g, NodeParams params, NodeIdxPair input, float epsilon, ITensorAccessorUPtr mean_accessor=nullptr, ITensorAccessorUPtr var_accessor=nullptr, ITensorAccessorUPtr beta_accessor=nullptr, ITensorAccessorUPtr gamma_accessor=nullptr)
	Adds a batch normalization layer node to the graph. More...
static NodeID	add_bounding_box_transform_node (Graph &g, NodeParams params, NodeIdxPair input, NodeIdxPair deltas, BoundingBoxTransformInfo info)
	Adds a bounding box transform layer node to the graph. More...
static NodeID	add_channel_shuffle_node (Graph &g, NodeParams params, NodeIdxPair input, unsigned int num_groups)
	Adds an channel shuffle layer node to the graph. More...
static NodeID	add_convolution_node (Graph &g, NodeParams params, NodeIdxPair input, Size2D kernel_spatial_extend, unsigned int depth, PadStrideInfo conv_info, unsigned int num_groups=1, ConvolutionMethod method=ConvolutionMethod::Default, FastMathHint fast_math_hint=FastMathHint::Disabled, ITensorAccessorUPtr weights_accessor=nullptr, ITensorAccessorUPtr bias_accessor=nullptr, const QuantizationInfo &weights_quant_info=QuantizationInfo(), const QuantizationInfo &out_quant_info=QuantizationInfo())
	Adds a convolution layer node to the graph. More...
static NodeID	add_deconvolution_node (Graph &g, NodeParams params, NodeIdxPair input, Size2D kernel_spatial_extend, unsigned int depth, PadStrideInfo deconv_info, ITensorAccessorUPtr weights_accessor=nullptr, ITensorAccessorUPtr bias_accessor=nullptr)
	Adds a deconvolution layer node to the graph. More...
static NodeID	add_concatenate_node (Graph &g, NodeParams params, const std::vector< NodeIdxPair > &inputs, const descriptors::ConcatLayerDescriptor &concat_descriptor)
	Adds a depth concatenate node to the graph. More...
static NodeID	add_depth_to_space_node (Graph &g, NodeParams params, NodeIdxPair input, int32_t block_shape)
	Adds an depth to space layer node to the graph. More...
static NodeID	add_depthwise_convolution_node (Graph &g, NodeParams params, NodeIdxPair input, Size2D kernel_spatial_extend, PadStrideInfo conv_info, int depth_multiplier=1, DepthwiseConvolutionMethod method=DepthwiseConvolutionMethod::Default, ITensorAccessorUPtr weights_accessor=nullptr, ITensorAccessorUPtr bias_accessor=nullptr, const QuantizationInfo &quant_info=QuantizationInfo(), const QuantizationInfo &out_quant_info=QuantizationInfo())
	Adds a depth-wise convolution layer node to the graph. More...
static NodeID	add_elementwise_node (Graph &g, NodeParams params, NodeIdxPair input0, NodeIdxPair input1, EltwiseOperation operation)
	Adds an element-wise layer node to the graph. More...
static NodeID	add_dequantization_node (Graph &g, NodeParams params, NodeIdxPair input)
	Adds a dequantization node to the graph. More...
static NodeID	add_detection_output_node (Graph &g, NodeParams params, NodeIdxPair input_loc, NodeIdxPair input_conf, NodeIdxPair input_priorbox, const DetectionOutputLayerInfo &detect_info)
	Adds a detection output layer node to the graph. More...
static NodeID	add_detection_post_process_node (Graph &g, NodeParams params, NodeIdxPair input_box_encoding, NodeIdxPair input_class_prediction, const DetectionPostProcessLayerInfo &detect_info, ITensorAccessorUPtr anchors_accessor=nullptr, const QuantizationInfo &anchor_quant_info=QuantizationInfo())
	Adds a detection post process layer node to the graph. More...
static NodeID	add_dummy_node (Graph &g, NodeParams params, NodeIdxPair input, TensorShape shape)
	Adds a Dummy node to the graph. More...
static NodeID	add_flatten_node (Graph &g, NodeParams params, NodeIdxPair input)
	Adds a flatten layer node to the graph. More...
static NodeID	add_fully_connected_layer (Graph &g, NodeParams params, NodeIdxPair input, unsigned int num_outputs, NodeID weights_nid, NodeID bias_nid=EmptyNodeID, const FullyConnectedLayerInfo fc_info=FullyConnectedLayerInfo(), const QuantizationInfo &out_quant_info=QuantizationInfo(), FastMathHint fast_math_hint=FastMathHint::Disabled)
	Adds a fully connected layer node to the graph. More...
static NodeID	add_fully_connected_layer (Graph &g, NodeParams params, NodeIdxPair input, unsigned int num_outputs, ITensorAccessorUPtr weights_accessor=nullptr, ITensorAccessorUPtr bias_accessor=nullptr, const FullyConnectedLayerInfo fc_info=FullyConnectedLayerInfo(), const QuantizationInfo &weights_quant_info=QuantizationInfo(), const QuantizationInfo &out_quant_info=QuantizationInfo(), FastMathHint fast_math_hint=FastMathHint::Disabled)
	Adds a fully connected layer node to the graph. More...
static NodeID	add_generate_proposals_node (Graph &g, NodeParams params, NodeIdxPair scores, NodeIdxPair deltas, NodeIdxPair anchors, GenerateProposalsInfo info)
	Adds a generate proposals layer node to the graph. More...
static NodeID	add_l2_normalize_node (Graph &g, NodeParams params, NodeIdxPair input, int axis, float epsilon)
	Adds a L2 Normalize layer node to the graph. More...
static NodeID	add_normalization_node (Graph &g, NodeParams params, NodeIdxPair input, NormalizationLayerInfo norm_info)
	Adds a normalization layer node to the graph. More...
static NodeID	add_normalize_planar_yuv_node (Graph &g, NodeParams params, NodeIdxPair input, ITensorAccessorUPtr mean_accessor=nullptr, ITensorAccessorUPtr std_accessor=nullptr)
	Adds a normalize planar YUV layer node to the graph. More...
static NodeID	add_pad_node (Graph &g, NodeParams params, NodeIdxPair input, const PaddingList &paddings, PixelValue pad_value=PixelValue())
	Adds a pad layer node to the graph. More...
static NodeID	add_permute_node (Graph &g, NodeParams params, NodeIdxPair input, PermutationVector perm, DataLayout layout=DataLayout::UNKNOWN)
	Adds a permute layer node to the graph. More...
static NodeID	add_pooling_node (Graph &g, NodeParams params, NodeIdxPair input, PoolingLayerInfo pool_info)
	Adds a pooling layer node to the graph. More...
static NodeID	add_prelu_node (Graph &g, NodeParams params, NodeIdxPair input, NodeIdxPair alpha)
	Adds a prelu layer node to the graph. More...
static NodeID	add_print_node (Graph &g, NodeParams params, NodeIdxPair input, std::ostream &stream, const IOFormatInfo &format_info=IOFormatInfo(), const std::function< ITensor *(ITensor *)> transform=nullptr)
	Adds a print layer node to the graph. More...
static NodeID	add_priorbox_node (Graph &g, NodeParams params, NodeIdxPair input0, NodeIdxPair input1, const PriorBoxLayerInfo &prior_info)
	Adds a priorbox layer node to the graph. More...
static NodeID	add_quantization_node (Graph &g, NodeParams params, NodeIdxPair input, const QuantizationInfo &out_quant_info)
	Adds a quantization layer node to the graph. More...
static NodeID	add_reduction_operation_node (Graph &g, NodeParams params, NodeIdxPair input, ReductionOperation op, int axis, bool keep_dims=true)
	Adds a reduction sum layer node to the graph. More...
static NodeID	add_reorg_node (Graph &g, NodeParams params, NodeIdxPair input, int stride)
	Adds a reorg layer node to the graph. More...
static NodeID	add_reshape_node (Graph &g, NodeParams params, NodeIdxPair input, TensorShape shape)
	Adds a reshape layer node to the graph. More...
static NodeID	add_resize_node (Graph &g, NodeParams params, NodeIdxPair input, InterpolationPolicy policy, float width_scale, float height_scale)
	Adds a resize layer node to the graph. More...
static NodeID	add_roi_align_node (Graph &g, NodeParams params, NodeIdxPair input, NodeIdxPair rois, ROIPoolingLayerInfo pool_info)
	Adds a ROI align layer node to the graph. More...
static NodeID	add_scale_layer (Graph &g, const NodeParams &params, NodeIdxPair input, ITensorAccessorUPtr mul_accessor=nullptr, ITensorAccessorUPtr add_accessor=nullptr)
	Adds a scale layer node to the graph This layer computes a product of the input with a scale (read from mul_accessor) and it applies an offset (read from add_accessor). More...
static NodeID	add_softmax_node (Graph &g, NodeParams params, NodeIdxPair input, float beta=1.f)
	Adds a softmax node to the graph. More...
static NodeID	add_slice_node (Graph &g, NodeParams params, NodeIdxPair input, Coordinates &starts, Coordinates &ends)
	Adds a slice node to the graph. More...
static NodeID	add_split_node (Graph &g, NodeParams params, NodeIdxPair input, unsigned int num_splits, unsigned int axis=0)
	Adds a split node to the graph. More...
static NodeID	add_stack_node (Graph &g, NodeParams params, const std::vector< NodeIdxPair > &inputs, int axis)
	Adds a stack layer node to the graph. More...
static NodeID	add_strided_slice_node (Graph &g, NodeParams params, NodeIdxPair input, Coordinates &starts, Coordinates &ends, BiStrides &strides, StridedSliceLayerInfo info)
	Adds a strided slice node to the graph. More...
static NodeID	add_yolo_node (Graph &g, NodeParams params, NodeIdxPair input, ActivationLayerInfo act_info)
	Adds a yolo layer to the graph. More...

Detailed Description

Graph builder class.

Builds and compiles a graph

Definition at line 42 of file GraphBuilder.h.

Member Function Documentation

add_activation_node()

NodeID add_activation_node ( Graph &  g, NodeParams  params, NodeIdxPair  input, ActivationLayerInfo  act_info, const QuantizationInfo &  out_quant_info = QuantizationInfo()  )

static

Adds an activation layer node to the graph.

Parameters

[in]	g	Graph to add the node to
[in]	params	Common node parameters
[in]	input	Input to the activation layer node as a NodeID-Index pair
[in]	act_info	Activation layer information
[in]	out_quant_info	(Optional) Output quantization info

Returns

Node ID of the created node, EmptyNodeID in case of error

Definition at line 137 of file GraphBuilder.cpp.

{
    return create_simple_single_input_output_node<ActivationLayerNode>(g, params, input, act_info, out_quant_info);
}

References arm_compute::test::validation::act_info, and arm_compute::test::validation::input.

Referenced by ActivationLayer::create_layer().

add_arg_min_max_node()

NodeID add_arg_min_max_node ( Graph &  g, NodeParams  params, NodeIdxPair  input, ReductionOperation  op, unsigned int  axis, DataType  out_data_type = DataType::UNKNOWN, const QuantizationInfo &  out_quant_info = QuantizationInfo()  )

static

Adds an activation layer node to the graph.

Parameters

[in]	g	Graph to add the node to
[in]	params	Common node parameters
[in]	input	Input to the activation layer node as a NodeID-Index pair
[in]	op	Reduction Operation: min or max
[in]	axis	Axis to perform reduction operation across
[in]	out_data_type	(Optional) Output data type
[in]	out_quant_info	(Optional) Output quantization info

Returns

Node ID of the created node, EmptyNodeID in case of error

Definition at line 143 of file GraphBuilder.cpp.

{
    return create_simple_single_input_output_node<ArgMinMaxLayerNode>(g, params, input, op, axis, out_data_type, out_quant_info);
}

References arm_compute::test::validation::input.

Referenced by ArgMinMaxLayer::create_layer().

add_batch_normalization_node()

NodeID add_batch_normalization_node ( Graph &  g, NodeParams  params, NodeIdxPair  input, float  epsilon, ITensorAccessorUPtr  mean_accessor = nullptr, ITensorAccessorUPtr  var_accessor = nullptr, ITensorAccessorUPtr  beta_accessor = nullptr, ITensorAccessorUPtr  gamma_accessor = nullptr  )

static

Adds a batch normalization layer node to the graph.

Parameters

[in]	g	Graph to add the node to
[in]	params	Common node parameters
[in]	input	Input to the batch normalization layer node as a NodeID-Index pair
[in]	epsilon	Epsilon parameter
[in]	mean_accessor	Const Node ID that contains the mean values
[in]	var_accessor	Const Node ID that contains the variance values
[in]	beta_accessor	Const Node ID that contains the beta values. Can be EmptyNodeID
[in]	gamma_accessor	Const Node ID that contains the gamma values. Can be EmptyNodeID

Returns

Node ID of the created node, EmptyNodeID in case of error

Definition at line 149 of file GraphBuilder.cpp.

{
    check_nodeidx_pair(input, g);
 
    bool has_beta  = (beta_accessor != nullptr);
    bool has_gamma = (gamma_accessor != nullptr);
 
    // Get input tensor descriptor
    const TensorDescriptor input_tensor_desc = get_tensor_descriptor(g, g.node(input.node_id)->outputs()[0]);
 
    // Calculate Common Descriptor
    TensorDescriptor common_desc = input_tensor_desc;
    common_desc.shape            = TensorShape(get_dimension_size(input_tensor_desc, DataLayoutDimension::CHANNEL));
 
    // Create mean and var nodes
    auto mean_nid = add_const_node_with_name(g, params, "Mean", common_desc, std::move(mean_accessor));
    auto var_nid  = add_const_node_with_name(g, params, "Variance", common_desc, std::move(var_accessor));
 
    // Create beta node
    NodeID beta_nid = EmptyNodeID;
    if(has_beta)
    {
        beta_nid = add_const_node_with_name(g, params, "Beta", common_desc, std::move(beta_accessor));
    }
 
    // Create gamma node
    NodeID gamma_nid = EmptyNodeID;
    if(has_gamma)
    {
        gamma_nid = add_const_node_with_name(g, params, "Gamma", common_desc, std::move(gamma_accessor));
    }
 
    // Create batch normalization node and add connections
    NodeID batch_norm_nid = g.add_node<BatchNormalizationLayerNode>(epsilon);
    g.add_connection(input.node_id, input.index, batch_norm_nid, 0);
    g.add_connection(mean_nid, 0, batch_norm_nid, 1);
    g.add_connection(var_nid, 0, batch_norm_nid, 2);
    if(has_beta)
    {
        g.add_connection(beta_nid, 0, batch_norm_nid, 3);
    }
    if(has_gamma)
    {
        g.add_connection(gamma_nid, 0, batch_norm_nid, 4);
    }
    set_node_params(g, batch_norm_nid, params);
 
    return batch_norm_nid;
}

References Graph::add_connection(), Graph::add_node(), arm_compute::CHANNEL, arm_compute::graph::EmptyNodeID, arm_compute::quantization::epsilon, arm_compute::graph::get_dimension_size(), arm_compute::graph::get_tensor_descriptor(), arm_compute::test::validation::input, Graph::node(), INode::outputs(), and TensorDescriptor::shape.

Referenced by BatchNormalizationLayer::create_layer().

add_bounding_box_transform_node()

NodeID add_bounding_box_transform_node ( Graph &  g, NodeParams  params, NodeIdxPair  input, NodeIdxPair  deltas, BoundingBoxTransformInfo  info  )

static

Adds a bounding box transform layer node to the graph.

Parameters

[in]	g	Graph to add the node to
[in]	params	Common node parameters
[in]	input	Input to the bounding box transform layer node as a NodeID-Index pair
[in]	deltas	Deltas input to the bounding box transform layer node as a NodeID-Index pair
[in]	info	Bounding Box Transform information

Returns

Node ID of the created node, EmptyNodeID in case of error

Definition at line 201 of file GraphBuilder.cpp.

{
    check_nodeidx_pair(input, g);
    check_nodeidx_pair(deltas, g);
 
    NodeID nid = g.add_node<BoundingBoxTransformLayerNode>(info);
 
    g.add_connection(input.node_id, input.index, nid, 0);
    g.add_connection(deltas.node_id, deltas.index, nid, 1);
 
    set_node_params(g, nid, params);
    return nid;
}

References Graph::add_connection(), Graph::add_node(), NodeIdxPair::index, arm_compute::test::validation::info, arm_compute::test::validation::input, and NodeIdxPair::node_id.

Referenced by BoundingBoxTransformLayer::create_layer().

add_channel_shuffle_node()

NodeID add_channel_shuffle_node ( Graph &  g, NodeParams  params, NodeIdxPair  input, unsigned int  num_groups  )

static

Adds an channel shuffle layer node to the graph.

Parameters

[in]	g	Graph to add the node to
[in]	params	Common node parameters
[in]	input	Input to the activation layer node as a NodeID-Index pair
[in]	num_groups	Number of groups

Returns

Node ID of the created node, EmptyNodeID in case of error

Definition at line 215 of file GraphBuilder.cpp.

{
    return create_simple_single_input_output_node<ChannelShuffleLayerNode>(g, params, input, num_groups);
}

References arm_compute::test::validation::input, and arm_compute::test::validation::num_groups.

Referenced by ChannelShuffleLayer::create_layer().

add_concatenate_node()

NodeID add_concatenate_node ( Graph &  g, NodeParams  params, const std::vector< NodeIdxPair > &  inputs, const descriptors::ConcatLayerDescriptor &  concat_descriptor  )

static

Adds a depth concatenate node to the graph.

Parameters

[in]	g	Graph to add the node to
[in]	params	Common node parameters
[in]	inputs	Inputs to the concatenate layer node as a NodeID-Index pair
[in]	concat_descriptor	Concatenation layer descriptor

Returns

Node ID of the created node, EmptyNodeID in case of error

Definition at line 328 of file GraphBuilder.cpp.

{
    return create_simple_multiple_input_single_output_node<ConcatenateLayerNode>(g, params, inputs, inputs.size(), concat_descriptor);
}

Referenced by ConcatLayer::create_layer().

add_const_node()

NodeID add_const_node ( Graph &  g, NodeParams  params, const TensorDescriptor &  desc, ITensorAccessorUPtr  accessor = nullptr  )

static

Adds a Const node to the graph.

Parameters

[in]	g	Graph to add the node to
[in]	params	Common node parameters
[in]	desc	Tensor descriptor of the node
[in]	accessor	(Optional) Accessor of the const node data

Returns

Node ID of the created node, EmptyNodeID in case of error

Definition at line 109 of file GraphBuilder.cpp.

{
    auto nid = g.add_node<ConstNode>(desc);
    set_node_params(g, nid, params);
    set_accessor_on_node(g, nid, true, 0, std::move(accessor));
    return nid;
}

References Graph::add_node().

Referenced by ConstantLayer::create_layer().

add_convolution_node()

NodeID add_convolution_node ( Graph &  g, NodeParams  params, NodeIdxPair  input, Size2D  kernel_spatial_extend, unsigned int  depth, PadStrideInfo  conv_info, unsigned int  num_groups = 1, ConvolutionMethod  method = ConvolutionMethod::Default, FastMathHint  fast_math_hint = FastMathHint::Disabled, ITensorAccessorUPtr  weights_accessor = nullptr, ITensorAccessorUPtr  bias_accessor = nullptr, const QuantizationInfo &  weights_quant_info = QuantizationInfo(), const QuantizationInfo &  out_quant_info = QuantizationInfo()  )

static

Adds a convolution layer node to the graph.

Parameters

[in]	g	Graph to add the node to
[in]	params	Common node parameters
[in]	input	Input to the convolution layer node as a NodeID-Index pair
[in]	kernel_spatial_extend	Spatial extend of convolution kernels
[in]	depth	Number of convolution kernels
[in]	conv_info	Convolution layer information
[in]	num_groups	(Optional) Number of groups for a grouped convolution. Defaults to 1
[in]	method	(Optional) Convolution method to use
[in]	fast_math_hint	(Optional) Fast math hint
[in]	weights_accessor	(Optional) Accessor of the weights node data
[in]	bias_accessor	(Optional) Accessor of the bias node data
[in]	weights_quant_info	(Optional) Weights quantization info
[in]	out_quant_info	(Optional) Output quantization info

Returns

Node ID of the created node, EmptyNodeID in case of error

Definition at line 220 of file GraphBuilder.cpp.

{
    check_nodeidx_pair(input, g);
    ARM_COMPUTE_ERROR_ON(depth == 0);
    ARM_COMPUTE_ERROR_ON((kernel_spatial_extend.width == 0) || (kernel_spatial_extend.height == 0));
 
    bool has_bias = (bias_accessor != nullptr);
 
    // Get input tensor descriptor
    const TensorDescriptor input_tensor_desc = get_tensor_descriptor(g, g.node(input.node_id)->outputs()[0]);
    const DataLayout       input_data_layout = input_tensor_desc.layout;
 
    // Create weights node
    TensorDescriptor w_desc = input_tensor_desc;
    w_desc.shape.set(get_dimension_idx(input_data_layout, DataLayoutDimension::WIDTH), kernel_spatial_extend.width);
    w_desc.shape.set(get_dimension_idx(input_data_layout, DataLayoutDimension::HEIGHT), kernel_spatial_extend.height);
    w_desc.shape.set(get_dimension_idx(input_data_layout, DataLayoutDimension::CHANNEL),
                     get_dimension_size(input_tensor_desc, DataLayoutDimension::CHANNEL) / num_groups);
    w_desc.shape.set(get_dimension_idx(input_data_layout, DataLayoutDimension::BATCHES), depth);
    if(!weights_quant_info.empty())
    {
        w_desc.quant_info = weights_quant_info;
    }
 
    NodeID w_nid = add_const_node_with_name(g, params, "Weights", w_desc, std::move(weights_accessor));
 
    // Create bias nodes
    NodeID b_nid = EmptyNodeID;
    if(has_bias)
    {
        TensorDescriptor b_desc = input_tensor_desc;
        b_desc.shape            = TensorShape(depth);
        if(is_data_type_quantized_asymmetric(input_tensor_desc.data_type))
        {
            b_desc.data_type = DataType::S32;
        }
        b_nid = add_const_node_with_name(g, params, "Bias", b_desc, std::move(bias_accessor));
    }
 
    // Create convolution node and connect
    NodeID conv_nid = g.add_node<ConvolutionLayerNode>(conv_info, num_groups, method, fast_math_hint, out_quant_info);
    g.add_connection(input.node_id, input.index, conv_nid, 0);
    g.add_connection(w_nid, 0, conv_nid, 1);
    if(has_bias)
    {
        g.add_connection(b_nid, 0, conv_nid, 2);
    }
    set_node_params(g, conv_nid, params);
 
    return conv_nid;
}

References Graph::add_connection(), Graph::add_node(), ARM_COMPUTE_ERROR_ON, arm_compute::BATCHES, arm_compute::CHANNEL, arm_compute::test::validation::conv_info, TensorDescriptor::data_type, QuantizationInfo::empty(), arm_compute::graph::EmptyNodeID, arm_compute::graph::get_dimension_idx(), arm_compute::graph::get_dimension_size(), arm_compute::graph::get_tensor_descriptor(), arm_compute::test::validation::has_bias, Size2D::height, arm_compute::HEIGHT, arm_compute::test::validation::input, arm_compute::is_data_type_quantized_asymmetric(), TensorDescriptor::layout, Graph::node(), arm_compute::test::validation::num_groups, INode::outputs(), TensorDescriptor::quant_info, arm_compute::S32, TensorShape::set(), TensorDescriptor::shape, Size2D::width, and arm_compute::WIDTH.

Referenced by ConvolutionLayer::create_layer().

add_deconvolution_node()

NodeID add_deconvolution_node ( Graph &  g, NodeParams  params, NodeIdxPair  input, Size2D  kernel_spatial_extend, unsigned int  depth, PadStrideInfo  deconv_info, ITensorAccessorUPtr  weights_accessor = nullptr, ITensorAccessorUPtr  bias_accessor = nullptr  )

static

Adds a deconvolution layer node to the graph.

Parameters

[in]	g	Graph to add the node to
[in]	params	Common node parameters
[in]	input	Input to the convolution layer node as a NodeID-Index pair
[in]	kernel_spatial_extend	Spatial extend of convolution kernels
[in]	depth	Number of convolution kernels
[in]	deconv_info	Convolution layer information
[in]	weights_accessor	(Optional) Accessor of the weights node data
[in]	bias_accessor	(Optional) Accessor of the bias node data

Returns

Node ID of the created node, EmptyNodeID in case of error

Definition at line 277 of file GraphBuilder.cpp.

{
    check_nodeidx_pair(input, g);
    ARM_COMPUTE_ERROR_ON(depth == 0);
    ARM_COMPUTE_ERROR_ON((kernel_spatial_extend.width == 0) || (kernel_spatial_extend.height == 0));
 
    bool has_bias = (bias_accessor != nullptr);
 
    // Get input tensor descriptor
    const TensorDescriptor input_tensor_desc = get_tensor_descriptor(g, g.node(input.node_id)->outputs()[0]);
    const DataLayout       input_data_layout = input_tensor_desc.layout;
 
    // Create weights node
    TensorDescriptor w_desc = input_tensor_desc;
    w_desc.shape.set(get_dimension_idx(input_data_layout, DataLayoutDimension::WIDTH), kernel_spatial_extend.width);
    w_desc.shape.set(get_dimension_idx(input_data_layout, DataLayoutDimension::HEIGHT), kernel_spatial_extend.height);
    w_desc.shape.set(get_dimension_idx(input_data_layout, DataLayoutDimension::CHANNEL),
                     get_dimension_size(input_tensor_desc, DataLayoutDimension::CHANNEL));
    w_desc.shape.set(get_dimension_idx(input_data_layout, DataLayoutDimension::BATCHES), depth);
 
    NodeID w_nid = add_const_node_with_name(g, params, "Weights", w_desc, std::move(weights_accessor));
 
    // Create bias nodes
    NodeID b_nid = EmptyNodeID;
    if(has_bias)
    {
        TensorDescriptor b_desc = input_tensor_desc;
        b_desc.shape            = TensorShape(depth);
        if(is_data_type_quantized_asymmetric(input_tensor_desc.data_type))
        {
            b_desc.data_type = DataType::S32;
        }
        b_nid = add_const_node_with_name(g, params, "Bias", b_desc, std::move(bias_accessor));
    }
 
    // Create convolution node and connect
    NodeID deconv_nid = g.add_node<DeconvolutionLayerNode>(descriptors::DeconvolutionLayerDescriptor{ deconv_info });
    g.add_connection(input.node_id, input.index, deconv_nid, 0);
    g.add_connection(w_nid, 0, deconv_nid, 1);
    if(has_bias)
    {
        g.add_connection(b_nid, 0, deconv_nid, 2);
    }
    set_node_params(g, deconv_nid, params);
 
    return deconv_nid;
}

References Graph::add_connection(), Graph::add_node(), ARM_COMPUTE_ERROR_ON, arm_compute::BATCHES, arm_compute::CHANNEL, TensorDescriptor::data_type, arm_compute::graph::EmptyNodeID, arm_compute::graph::get_dimension_idx(), arm_compute::graph::get_dimension_size(), arm_compute::graph::get_tensor_descriptor(), arm_compute::test::validation::has_bias, Size2D::height, arm_compute::HEIGHT, arm_compute::test::validation::input, arm_compute::is_data_type_quantized_asymmetric(), TensorDescriptor::layout, Graph::node(), INode::outputs(), arm_compute::S32, TensorShape::set(), TensorDescriptor::shape, Size2D::width, and arm_compute::WIDTH.

Referenced by DeconvolutionLayer::create_layer().

add_depth_to_space_node()

NodeID add_depth_to_space_node ( Graph &  g, NodeParams  params, NodeIdxPair  input, int32_t  block_shape  )

static

Adds an depth to space layer node to the graph.

Parameters

[in]	g	Graph to add the node to
[in]	params	Common node parameters
[in]	input	Input to the depth to space layer node as a NodeID-Index pair
[in]	block_shape	Block shape to reshape tensor with

Returns

Node ID of the created node, EmptyNodeID in case of error

Definition at line 387 of file GraphBuilder.cpp.

{
    return create_simple_single_input_output_node<DepthToSpaceLayerNode>(g, params, input, block_shape);
}

References arm_compute::test::validation::input.

Referenced by DepthToSpaceLayer::create_layer().

add_depthwise_convolution_node()

NodeID add_depthwise_convolution_node ( Graph &  g, NodeParams  params, NodeIdxPair  input, Size2D  kernel_spatial_extend, PadStrideInfo  conv_info, int  depth_multiplier = 1, DepthwiseConvolutionMethod  method = DepthwiseConvolutionMethod::Default, ITensorAccessorUPtr  weights_accessor = nullptr, ITensorAccessorUPtr  bias_accessor = nullptr, const QuantizationInfo &  quant_info = QuantizationInfo(), const QuantizationInfo &  out_quant_info = QuantizationInfo()  )

static

Adds a depth-wise convolution layer node to the graph.

Parameters

[in]	g	Graph to add the node to
[in]	params	Common node parameters
[in]	input	Input to the depthwise convolution layer node as a NodeID-Index pair
[in]	kernel_spatial_extend	Spatial extend of convolution kernels
[in]	conv_info	Convolution layer information
[in]	depth_multiplier	(Optional) Depth multiplier parameter.
[in]	method	(Optional) Convolution method to use
[in]	weights_accessor	(Optional) Accessor of the weights node data
[in]	bias_accessor	(Optional) Accessor of the bias node data
[in]	quant_info	(Optional) Weights quantization info
[in]	out_quant_info	(Optional) Output quantization info

Returns

Node ID of the created node, EmptyNodeID in case of error

Definition at line 333 of file GraphBuilder.cpp.

{
    check_nodeidx_pair(input, g);
    ARM_COMPUTE_ERROR_ON((kernel_spatial_extend.width == 0) || (kernel_spatial_extend.height == 0));
 
    bool has_bias = (bias_accessor != nullptr);
 
    // Get input tensor descriptor
    const TensorDescriptor input_tensor_desc = get_tensor_descriptor(g, g.node(input.node_id)->outputs()[0]);
    const DataLayout       input_data_layout = input_tensor_desc.layout;
 
    // Create weights node
    TensorDescriptor w_desc = input_tensor_desc;
    w_desc.shape.set(get_dimension_idx(input_data_layout, DataLayoutDimension::WIDTH), kernel_spatial_extend.width);
    w_desc.shape.set(get_dimension_idx(input_data_layout, DataLayoutDimension::HEIGHT), kernel_spatial_extend.height);
    w_desc.shape.set(get_dimension_idx(input_data_layout, DataLayoutDimension::CHANNEL),
                     get_dimension_size(input_tensor_desc, DataLayoutDimension::CHANNEL) * depth_multiplier);
    if(!quant_info.empty())
    {
        w_desc.quant_info = quant_info;
    }
 
    NodeID w_nid = add_const_node_with_name(g, params, "Weights", w_desc, std::move(weights_accessor));
 
    // Create bias nodes
    NodeID b_nid = EmptyNodeID;
    if(has_bias)
    {
        TensorDescriptor b_desc = input_tensor_desc;
        b_desc.shape            = TensorShape(get_dimension_size(input_tensor_desc, DataLayoutDimension::CHANNEL) * depth_multiplier);
 
        if(is_data_type_quantized_asymmetric(b_desc.data_type))
        {
            b_desc.data_type = DataType::S32;
        }
 
        b_nid = add_const_node_with_name(g, params, "Bias", b_desc, std::move(bias_accessor));
    }
 
    // Create convolution node and connect
    NodeID conv_nid = g.add_node<DepthwiseConvolutionLayerNode>(conv_info, depth_multiplier, method, out_quant_info);
    g.add_connection(input.node_id, input.index, conv_nid, 0);
    g.add_connection(w_nid, 0, conv_nid, 1);
    if(has_bias)
    {
        g.add_connection(b_nid, 0, conv_nid, 2);
    }
    set_node_params(g, conv_nid, params);
 
    return conv_nid;
}

References Graph::add_connection(), Graph::add_node(), ARM_COMPUTE_ERROR_ON, arm_compute::CHANNEL, arm_compute::test::validation::conv_info, TensorDescriptor::data_type, QuantizationInfo::empty(), arm_compute::graph::EmptyNodeID, arm_compute::graph::get_dimension_idx(), arm_compute::graph::get_dimension_size(), arm_compute::graph::get_tensor_descriptor(), arm_compute::test::validation::has_bias, Size2D::height, arm_compute::HEIGHT, arm_compute::test::validation::input, arm_compute::is_data_type_quantized_asymmetric(), TensorDescriptor::layout, Graph::node(), INode::outputs(), TensorDescriptor::quant_info, arm_compute::S32, TensorShape::set(), TensorDescriptor::shape, Size2D::width, and arm_compute::WIDTH.

Referenced by DepthwiseConvolutionLayer::create_layer().

add_dequantization_node()

NodeID add_dequantization_node ( Graph &  g, NodeParams  params, NodeIdxPair  input  )

static

Adds a dequantization node to the graph.

Parameters

[in]	g	Graph to add the node to
[in]	params	Common node parameters
[in]	input	Input to the dequantization node as a NodeID-Index pair

Returns

Node ID of the created node, EmptyNodeID in case of error

Definition at line 392 of file GraphBuilder.cpp.

{
    return create_simple_single_input_output_node<DequantizationLayerNode>(g, params, input);
}

References arm_compute::test::validation::input.

Referenced by DequantizationLayer::create_layer().

add_detection_output_node()

NodeID add_detection_output_node ( Graph &  g, NodeParams  params, NodeIdxPair  input_loc, NodeIdxPair  input_conf, NodeIdxPair  input_priorbox, const DetectionOutputLayerInfo &  detect_info  )

static

Adds a detection output layer node to the graph.

Parameters

[in]	g	Graph to add the node to
[in]	params	Common node parameters
[in]	input_loc	Location input to the detection output layer node as a NodeID-Index pair
[in]	input_conf	Confidence input to the detection output layer node as a NodeID-Index pair
[in]	input_priorbox	PriorBox input to the detection output layer node as a NodeID-Index pair
[in]	detect_info	Detection output layer parameters

Returns

Node ID of the created node, EmptyNodeID in case of error

Definition at line 397 of file GraphBuilder.cpp.

{
    check_nodeidx_pair(input_loc, g);
    check_nodeidx_pair(input_conf, g);
    check_nodeidx_pair(input_priorbox, g);
 
    // Create detection_output node and connect
    NodeID detect_nid = g.add_node<DetectionOutputLayerNode>(detect_info);
    g.add_connection(input_loc.node_id, input_loc.index, detect_nid, 0);
    g.add_connection(input_conf.node_id, input_conf.index, detect_nid, 1);
    g.add_connection(input_priorbox.node_id, input_priorbox.index, detect_nid, 2);
 
    set_node_params(g, detect_nid, params);
 
    return detect_nid;
}

References Graph::add_connection(), Graph::add_node(), NodeIdxPair::index, and NodeIdxPair::node_id.

Referenced by DetectionOutputLayer::create_layer().

add_detection_post_process_node()

NodeID add_detection_post_process_node ( Graph &  g, NodeParams  params, NodeIdxPair  input_box_encoding, NodeIdxPair  input_class_prediction, const DetectionPostProcessLayerInfo &  detect_info, ITensorAccessorUPtr  anchors_accessor = nullptr, const QuantizationInfo &  anchor_quant_info = QuantizationInfo()  )

static

Adds a detection post process layer node to the graph.

Parameters

[in]	g	Graph to add the node to
[in]	params	Common node parameters
[in]	input_box_encoding	Boxes input to the detection output layer node as a NodeID-Index pair
[in]	input_class_prediction	Class prediction input to the detection output layer node as a NodeID-Index pair
[in]	detect_info	Detection output layer parameters
[in]	anchors_accessor	(Optional) Const Node ID that contains the anchor values
[in]	anchor_quant_info	(Optional) Anchor quantization info

Returns

Node ID of the created node, EmptyNodeID in case of error

Definition at line 414 of file GraphBuilder.cpp.

{
    check_nodeidx_pair(input_box_encoding, g);
    check_nodeidx_pair(input_class_prediction, g);
 
    // Get input tensor descriptor
    const TensorDescriptor input_box_encoding_tensor_desc = get_tensor_descriptor(g, g.node(input_box_encoding.node_id)->outputs()[0]);
 
    // Calculate anchor descriptor
    TensorDescriptor anchor_desc = input_box_encoding_tensor_desc;
    if(!anchor_quant_info.empty())
    {
        anchor_desc.quant_info = anchor_quant_info;
    }
 
    // Create anchors nodes
    auto anchors_nid = add_const_node_with_name(g, params, "Anchors", anchor_desc, std::move(anchors_accessor));
 
    // Create detection_output node and connect
    NodeID detect_nid = g.add_node<DetectionPostProcessLayerNode>(detect_info);
    g.add_connection(input_box_encoding.node_id, input_box_encoding.index, detect_nid, 0);
    g.add_connection(input_class_prediction.node_id, input_class_prediction.index, detect_nid, 1);
    g.add_connection(anchors_nid, 0, detect_nid, 2);
 
    set_node_params(g, detect_nid, params);
 
    return detect_nid;
}

References Graph::add_connection(), Graph::add_node(), QuantizationInfo::empty(), arm_compute::graph::get_tensor_descriptor(), NodeIdxPair::index, Graph::node(), NodeIdxPair::node_id, INode::outputs(), and TensorDescriptor::quant_info.

Referenced by DetectionPostProcessLayer::create_layer().

add_dummy_node()

NodeID add_dummy_node ( Graph &  g, NodeParams  params, NodeIdxPair  input, TensorShape  shape  )

static

Adds a Dummy node to the graph.

Note

this node if for debugging purposes. Just alters the shape of the graph pipeline as requested.

Parameters

[in]	g	Graph to add the node to
[in]	params	Common node parameters
[in]	input	Input to the dummy node as a NodeID-Index pair
[in]	shape	Output shape

Returns

Node ID of the created node, EmptyNodeID in case of error

Definition at line 444 of file GraphBuilder.cpp.

{
    return create_simple_single_input_output_node<DummyNode>(g, params, input, shape);
}

References arm_compute::test::validation::input, and arm_compute::test::validation::shape.

Referenced by DummyLayer::create_layer().

add_elementwise_node()

NodeID add_elementwise_node ( Graph &  g, NodeParams  params, NodeIdxPair  input0, NodeIdxPair  input1, EltwiseOperation  operation  )

static

Adds an element-wise layer node to the graph.

Parameters

[in]	g	Graph to add the node to
[in]	params	Common node parameters
[in]	input0	First input to the element-wise operation layer node as a NodeID-Index pair
[in]	input1	Second input to the element-wise operation layer node as a NodeID-Index pair
[in]	operation	Element-wise operation to perform

Returns

Node ID of the created node, EmptyNodeID in case of error

Definition at line 449 of file GraphBuilder.cpp.

{
    check_nodeidx_pair(input0, g);
    check_nodeidx_pair(input1, g);
 
    NodeID nid = g.add_node<EltwiseLayerNode>(descriptors::EltwiseLayerDescriptor{ operation });
 
    g.add_connection(input0.node_id, input0.index, nid, 0);
    g.add_connection(input1.node_id, input1.index, nid, 1);
 
    set_node_params(g, nid, params);
 
    return nid;
}

References Graph::add_connection(), Graph::add_node(), NodeIdxPair::index, and NodeIdxPair::node_id.

Referenced by GraphBuilder::add_scale_layer(), and EltwiseLayer::create_layer().

add_flatten_node()

NodeID add_flatten_node ( Graph &  g, NodeParams  params, NodeIdxPair  input  )

static

Adds a flatten layer node to the graph.

Parameters

[in]	g	Graph to add the node to
[in]	params	Common node parameters
[in]	input	Input to the flatten layer node as a NodeID-Index pair

Returns

Node ID of the created node, EmptyNodeID in case of error

Definition at line 464 of file GraphBuilder.cpp.

{
    return create_simple_single_input_output_node<FlattenLayerNode>(g, params, input);
}

References arm_compute::test::validation::input.

Referenced by FlattenLayer::create_layer().

add_fully_connected_layer() [1/2]

NodeID add_fully_connected_layer ( Graph &  g, NodeParams  params, NodeIdxPair  input, unsigned int  num_outputs, ITensorAccessorUPtr  weights_accessor = nullptr, ITensorAccessorUPtr  bias_accessor = nullptr, const FullyConnectedLayerInfo  fc_info = FullyConnectedLayerInfo(), const QuantizationInfo &  weights_quant_info = QuantizationInfo(), const QuantizationInfo &  out_quant_info = QuantizationInfo(), FastMathHint  fast_math_hint = FastMathHint::Disabled  )

static

Adds a fully connected layer node to the graph.

Parameters

[in]	g	Graph to add the layer to
[in]	params	Common node parameters
[in]	input	Input to the fully connected layer node as a NodeID-Index pair
[in]	num_outputs	Number of output neurons
[in]	weights_accessor	(Optional) Accessor of the weights node data
[in]	bias_accessor	(Optional) Accessor of the bias node data
[in]	fc_info	(Optional) Fully connected layer metadata
[in]	weights_quant_info	(Optional) Weights quantization info
[in]	out_quant_info	(Optional) Output quantization info
[in]	fast_math_hint	(Optional) Fast math hint

Returns

Node ID of the created node, EmptyNodeID in case of error

Definition at line 496 of file GraphBuilder.cpp.

{
    check_nodeidx_pair(input, g);
    ARM_COMPUTE_ERROR_ON(num_outputs == 0);
 
    bool has_bias = (bias_accessor != nullptr);
 
    // Get input tensor descriptor
    const TensorDescriptor input_tensor_desc = get_tensor_descriptor(g, g.node(input.node_id)->outputs()[0]);
 
    // Create weights node
    TensorDescriptor w_desc = FullyConnectedLayerNode::compute_weights_descriptor(input_tensor_desc, num_outputs, fc_info, weights_quant_info);
    NodeID           w_nid  = add_const_node_with_name(g, params, "Weights", w_desc, std::move(weights_accessor));
 
    // Create bias nodes
    NodeID b_nid = EmptyNodeID;
    if(has_bias)
    {
        TensorDescriptor b_desc = input_tensor_desc;
        b_desc.shape            = TensorShape(num_outputs);
        if(is_data_type_quantized_asymmetric(input_tensor_desc.data_type))
        {
            b_desc.data_type = DataType::S32;
        }
        b_nid = add_const_node_with_name(g, params, "Bias", b_desc, std::move(bias_accessor));
    }
 
    // Create fully connected node and connect
    NodeID fc_nid = g.add_node<FullyConnectedLayerNode>(num_outputs, out_quant_info, fc_info, fast_math_hint);
    g.add_connection(input.node_id, input.index, fc_nid, 0);
    g.add_connection(w_nid, 0, fc_nid, 1);
    if(has_bias)
    {
        g.add_connection(b_nid, 0, fc_nid, 2);
    }
 
    set_node_params(g, fc_nid, params);
 
    return fc_nid;
}

References Graph::add_connection(), Graph::add_node(), ARM_COMPUTE_ERROR_ON, FullyConnectedLayerNode::compute_weights_descriptor(), TensorDescriptor::data_type, arm_compute::graph::EmptyNodeID, arm_compute::graph::get_tensor_descriptor(), arm_compute::test::validation::has_bias, arm_compute::test::validation::input, arm_compute::is_data_type_quantized_asymmetric(), Graph::node(), INode::outputs(), arm_compute::S32, and TensorDescriptor::shape.

add_fully_connected_layer() [2/2]

NodeID add_fully_connected_layer ( Graph &  g, NodeParams  params, NodeIdxPair  input, unsigned int  num_outputs, NodeID  weights_nid, NodeID  bias_nid = EmptyNodeID, const FullyConnectedLayerInfo  fc_info = FullyConnectedLayerInfo(), const QuantizationInfo &  out_quant_info = QuantizationInfo(), FastMathHint  fast_math_hint = FastMathHint::Disabled  )

static

Adds a fully connected layer node to the graph.

Parameters

[in]	g	Graph to add the layer to
[in]	params	Common node parameters
[in]	input	Input to the fully connected layer node as a NodeID-Index pair
[in]	num_outputs	Number of output neurons
[in]	weights_nid	Node ID of the weights node data
[in]	bias_nid	(Optional) Node ID of the bias node data. Defaults to EmptyNodeID
[in]	fc_info	(Optional) Fully connected layer metadata
[in]	out_quant_info	(Optional) Output quantization info
[in]	fast_math_hint	(Optional) Fast math hint

Returns

Node ID of the created node, EmptyNodeID in case of error

Definition at line 469 of file GraphBuilder.cpp.

{
    check_nodeidx_pair(input, g);
    ARM_COMPUTE_ERROR_ON(num_outputs == 0);
    ARM_COMPUTE_ERROR_ON(weights_nid == EmptyNodeID);
 
    const bool has_bias = (bias_nid != EmptyNodeID);
 
    // Get input tensor descriptor
    const TensorDescriptor input_tensor_desc = get_tensor_descriptor(g, g.node(input.node_id)->outputs()[0]);
 
    // Create fully connected node and connect
    NodeID fc_nid = g.add_node<FullyConnectedLayerNode>(num_outputs, out_quant_info, fc_info, fast_math_hint);
    g.add_connection(input.node_id, input.index, fc_nid, 0);
    g.add_connection(weights_nid, 0, fc_nid, 1);
    if(has_bias)
    {
        g.add_connection(bias_nid, 0, fc_nid, 2);
    }
 
    set_node_params(g, fc_nid, params);
 
    return fc_nid;
}

References Graph::add_connection(), Graph::add_node(), ARM_COMPUTE_ERROR_ON, arm_compute::graph::EmptyNodeID, arm_compute::graph::get_tensor_descriptor(), arm_compute::test::validation::has_bias, arm_compute::test::validation::input, Graph::node(), and INode::outputs().

Referenced by FullyConnectedLayer::create_layer().

add_generate_proposals_node()

NodeID add_generate_proposals_node ( Graph &  g, NodeParams  params, NodeIdxPair  scores, NodeIdxPair  deltas, NodeIdxPair  anchors, GenerateProposalsInfo  info  )

static

Adds a generate proposals layer node to the graph.

Parameters

[in]	g	Graph to add the layer to
[in]	params	Common node parameters
[in]	scores	Input scores to the generate proposals layer node as a NodeID-Index pair
[in]	deltas	Input deltas to the generate proposals layer node as a NodeID-Index pair
[in]	anchors	Input anchors to the generate proposals layer node as a NodeID-Index pair
[in]	info	Generate proposals operation information

Returns

Node ID of the created node, EmptyNodeID in case of error

Definition at line 540 of file GraphBuilder.cpp.

{
    check_nodeidx_pair(scores, g);
    check_nodeidx_pair(deltas, g);
    check_nodeidx_pair(anchors, g);
 
    NodeID nid = g.add_node<GenerateProposalsLayerNode>(info);
 
    g.add_connection(scores.node_id, scores.index, nid, 0);
    g.add_connection(deltas.node_id, deltas.index, nid, 1);
    g.add_connection(anchors.node_id, anchors.index, nid, 2);
 
    set_node_params(g, nid, params);
    return nid;
}

References Graph::add_connection(), Graph::add_node(), NodeIdxPair::index, arm_compute::test::validation::info, and NodeIdxPair::node_id.

Referenced by GenerateProposalsLayer::create_layer().

add_input_node()

NodeID add_input_node ( Graph &  g, NodeParams  params, const TensorDescriptor &  desc, ITensorAccessorUPtr  accessor = nullptr  )

static

Adds an input layer node to the graph.

Parameters

[in]	g	Graph to add the node to
[in]	params	Common node parameters
[in]	desc	Tensor descriptor of the Tensor
[in]	accessor	(Optional) Accessor of the input node data

Returns

Node ID of the created node, EmptyNodeID in case of error

Definition at line 117 of file GraphBuilder.cpp.

{
    auto nid = g.add_node<InputNode>(desc);
    set_node_params(g, nid, params);
    set_accessor_on_node(g, nid, true, 0, std::move(accessor));
    return nid;
}

References Graph::add_node().

Referenced by InputLayer::create_layer().

add_l2_normalize_node()

NodeID add_l2_normalize_node ( Graph &  g, NodeParams  params, NodeIdxPair  input, int  axis, float  epsilon  )

static

Adds a L2 Normalize layer node to the graph.

Parameters

[in]	g	Graph to add the node to
[in]	params	Common node parameters
[in]	input	Input to the normalization layer node as a NodeID-Index pair
[in]	axis	Axis to perform normalization on
[in]	epsilon	Lower bound value for the normalization

Returns

Node ID of the created node, EmptyNodeID in case of error

Definition at line 556 of file GraphBuilder.cpp.

{
    return create_simple_single_input_output_node<L2NormalizeLayerNode>(g, params, input, axis, epsilon);
}

References arm_compute::quantization::epsilon, and arm_compute::test::validation::input.

Referenced by L2NormalizeLayer::create_layer().

add_normalization_node()

NodeID add_normalization_node ( Graph &  g, NodeParams  params, NodeIdxPair  input, NormalizationLayerInfo  norm_info  )

static

Adds a normalization layer node to the graph.

Parameters

[in]	g	Graph to add the node to
[in]	params	Common node parameters
[in]	input	Input to the normalization layer node as a NodeID-Index pair
[in]	norm_info	Normalization layer information

Returns

Node ID of the created node, EmptyNodeID in case of error

Definition at line 561 of file GraphBuilder.cpp.

{
    return create_simple_single_input_output_node<NormalizationLayerNode>(g, params, input, norm_info);
}

References arm_compute::test::validation::input.

Referenced by NormalizationLayer::create_layer().

add_normalize_planar_yuv_node()

NodeID add_normalize_planar_yuv_node ( Graph &  g, NodeParams  params, NodeIdxPair  input, ITensorAccessorUPtr  mean_accessor = nullptr, ITensorAccessorUPtr  std_accessor = nullptr  )

static

Adds a normalize planar YUV layer node to the graph.

Parameters

[in]	g	Graph to add the node to
[in]	params	Common node parameters
[in]	input	Input to the normalize planar YUV layer node as a NodeID-Index pair
[in]	mean_accessor	Const Node ID that contains the mean values
[in]	std_accessor	Const Node ID that contains the variance values

Returns

Node ID of the created node, EmptyNodeID in case of error

Definition at line 566 of file GraphBuilder.cpp.

{
    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]);
 
    // Calculate Common Descriptor
    TensorDescriptor common_desc = input_tensor_desc;
    common_desc.shape            = TensorShape(get_dimension_size(input_tensor_desc, DataLayoutDimension::CHANNEL));
 
    // Create mean and std nodes
    auto mean_nid = add_const_node_with_name(g, params, "Mean", common_desc, std::move(mean_accessor));
    auto std_nid  = add_const_node_with_name(g, params, "Std", common_desc, std::move(std_accessor));
 
    // Create normalize planar YUV node and add connections
    NodeID norm_planar_yuv_nid = g.add_node<NormalizePlanarYUVLayerNode>();
    g.add_connection(input.node_id, input.index, norm_planar_yuv_nid, 0);
    g.add_connection(mean_nid, 0, norm_planar_yuv_nid, 1);
    g.add_connection(std_nid, 0, norm_planar_yuv_nid, 2);
    set_node_params(g, norm_planar_yuv_nid, params);
 
    return norm_planar_yuv_nid;
}

References Graph::add_connection(), Graph::add_node(), arm_compute::CHANNEL, arm_compute::graph::get_dimension_size(), arm_compute::graph::get_tensor_descriptor(), arm_compute::test::validation::input, Graph::node(), INode::outputs(), and TensorDescriptor::shape.

Referenced by NormalizePlanarYUVLayer::create_layer().

add_output_node()

NodeID add_output_node ( Graph &  g, NodeParams  params, NodeIdxPair  input, ITensorAccessorUPtr  accessor = nullptr  )

static

Adds an output layer node to the graph.

Parameters

[in]	g	Graph to add the node to
[in]	params	Common node parameters
[in]	input	Input to the output node as a NodeID-Index pair
[in]	accessor	(Optional) Accessor of the output node data

Returns

Node ID of the created node, EmptyNodeID in case of error

Definition at line 125 of file GraphBuilder.cpp.

{
    check_nodeidx_pair(input, g);
 
    NodeID nid = g.add_node<OutputNode>();
    g.add_connection(input.node_id, input.index, nid, 0);
    set_node_params(g, nid, params);
    set_accessor_on_node(g, nid, false, 0, std::move(accessor));
 
    return nid;
}

References Graph::add_connection(), Graph::add_node(), and arm_compute::test::validation::input.

Referenced by OutputLayer::create_layer().

add_pad_node()

NodeID add_pad_node ( Graph &  g, NodeParams  params, NodeIdxPair  input, const PaddingList &  paddings, PixelValue  pad_value = PixelValue()  )

static

Adds a pad layer node to the graph.

Parameters

[in]	g	Graph to add the node to
[in]	params	Common node parameters
[in]	input	Input to the reshape layer node as a NodeID-Index pair
[in]	paddings	The padding for each spatial dimension of the input tensor. The pair padding[i] specifies the front and the end padding in the i-th dimension.
[in]	pad_value	Padding value to be used. Defaults to 0

Returns

Node ID of the created node, EmptyNodeID in case of error

Definition at line 592 of file GraphBuilder.cpp.

{
    return create_simple_single_input_output_node<PadLayerNode>(g, params, input, paddings, pad_value);
}

References arm_compute::test::validation::input.

Referenced by PadLayer::create_layer().

add_permute_node()

NodeID add_permute_node ( Graph &  g, NodeParams  params, NodeIdxPair  input, PermutationVector  perm, DataLayout  layout = DataLayout::UNKNOWN  )

static

Adds a permute layer node to the graph.

Parameters

[in]	g	Graph to add the node to
[in]	params	Common node parameters
[in]	input	Input to the reshape layer node as a NodeID-Index pair
[in]	perm	Permutation vector
[in]	layout	(Optional) Data layout to assign to permuted tensor. If UNKNOWN then the input's layout will be used.

Returns

Node ID of the created node, EmptyNodeID in case of error

Definition at line 597 of file GraphBuilder.cpp.

{
    return create_simple_single_input_output_node<PermuteLayerNode>(g, params, input, perm, layout);
}

References arm_compute::test::validation::input.

Referenced by PermuteLayer::create_layer().

add_pooling_node()

NodeID add_pooling_node ( Graph &  g, NodeParams  params, NodeIdxPair  input, PoolingLayerInfo  pool_info  )

static

Adds a pooling layer node to the graph.

Parameters

[in]	g	Graph to add the node to
[in]	params	Common node parameters
[in]	input	Input to the pooling layer node as a NodeID-Index pair
[in]	pool_info	Pooling layer information

Returns

Node ID of the created node, EmptyNodeID in case of error

Definition at line 616 of file GraphBuilder.cpp.

{
    return create_simple_single_input_output_node<PoolingLayerNode>(g, params, input, pool_info);
}

References arm_compute::test::validation::input.

Referenced by PoolingLayer::create_layer().

add_prelu_node()

NodeID add_prelu_node ( Graph &  g, NodeParams  params, NodeIdxPair  input, NodeIdxPair  alpha  )

static

Adds a prelu layer node to the graph.

Parameters

[in]	g	Graph to add the node to
[in]	params	Common node parameters
[in]	input	Input to the PRelu node as a NodeID-Index pair
[in]	alpha	Alpha input to the PRelu node as a NodeID-Index pair

Returns

Node ID of the created node, EmptyNodeID in case of error

Definition at line 602 of file GraphBuilder.cpp.

{
    check_nodeidx_pair(input, g);
    check_nodeidx_pair(alpha, g);
 
    NodeID prelu_nid = g.add_node<PReluLayerNode>();
    g.add_connection(input.node_id, input.index, prelu_nid, 0);
    g.add_connection(alpha.node_id, alpha.index, prelu_nid, 1);
 
    set_node_params(g, prelu_nid, params);
 
    return prelu_nid;
}

References Graph::add_connection(), Graph::add_node(), NodeIdxPair::index, arm_compute::test::validation::input, and NodeIdxPair::node_id.

Referenced by PReluLayer::create_layer().

add_print_node()

NodeID add_print_node ( Graph &  g, NodeParams  params, NodeIdxPair  input, std::ostream &  stream, const IOFormatInfo &  format_info = IOFormatInfo(), const std::function< ITensor *(ITensor *)>  transform = nullptr  )

static

Adds a print layer node to the graph.

Parameters

[in]	g	Graph to add the node to
[in]	params	Common node parameters
[in]	input	Input to the print layer node as a NodeID-Index pair
[in]	stream	Output stream.
[in]	format_info	(Optional) Format info.
[in]	transform	(Optional) Transformation function to be applied to the input tensor before printing.

Returns

Node ID of the created node, EmptyNodeID in case of error

Definition at line 621 of file GraphBuilder.cpp.

{
    return create_simple_single_input_output_node<PrintLayerNode>(g, params, input, stream, format_info, transform);
}

References arm_compute::test::validation::input.

Referenced by PrintLayer::create_layer().

add_priorbox_node()

NodeID add_priorbox_node ( Graph &  g, NodeParams  params, NodeIdxPair  input0, NodeIdxPair  input1, const PriorBoxLayerInfo &  prior_info  )

static

Adds a priorbox layer node to the graph.

Parameters

[in]	g	Graph to add the node to
[in]	params	Common node parameters
[in]	input0	First input to the priorbox layer node as a NodeID-Index pair
[in]	input1	Second input to the priorbox layer node as a NodeID-Index pair
[in]	prior_info	PriorBox parameters

Returns

Node ID of the created node, EmptyNodeID in case of error

Definition at line 626 of file GraphBuilder.cpp.

{
    check_nodeidx_pair(input0, g);
    check_nodeidx_pair(input1, g);
 
    // Create priorbox node and connect
    NodeID prior_nid = g.add_node<PriorBoxLayerNode>(prior_info);
    g.add_connection(input0.node_id, input0.index, prior_nid, 0);
    g.add_connection(input1.node_id, input1.index, prior_nid, 1);
 
    set_node_params(g, prior_nid, params);
 
    return prior_nid;
}

References Graph::add_connection(), Graph::add_node(), NodeIdxPair::index, and NodeIdxPair::node_id.

Referenced by PriorBoxLayer::create_layer().

add_quantization_node()

NodeID add_quantization_node ( Graph &  g, NodeParams  params, NodeIdxPair  input, const QuantizationInfo &  out_quant_info  )

static

Adds a quantization layer node to the graph.

Parameters

[in]	g	Graph to add the node to
[in]	params	Common node parameters
[in]	input	Input to the quantization layer node as a NodeID-Index pair
[in]	out_quant_info	Output quantization info

Returns

Node ID of the created node, EmptyNodeID in case of error

Definition at line 641 of file GraphBuilder.cpp.

{
    return create_simple_single_input_output_node<QuantizationLayerNode>(g, params, input, out_quant_info);
}

References arm_compute::test::validation::input.

Referenced by QuantizationLayer::create_layer().

add_reduction_operation_node()

NodeID add_reduction_operation_node ( Graph &  g, NodeParams  params, NodeIdxPair  input, ReductionOperation  op, int  axis, bool  keep_dims = true  )

static

Adds a reduction sum layer node to the graph.

Parameters

[in]	g	Graph to add the node to
[in]	params	Common node parameters
[in]	input	Input to the reorg layer node as a NodeID-Index pair
[in]	op	Reduction operation
[in]	axis	Reduction axis
[in]	keep_dims	(Optional) Whether to keep the reduced dimension after the operation. Defaults to true.

Returns

Node ID of the created node, EmptyNodeID in case of error

Definition at line 646 of file GraphBuilder.cpp.

{
    return create_simple_single_input_output_node<ReductionLayerNode>(g, params, input, op, axis, keep_dims);
}

References arm_compute::test::validation::input.

Referenced by ReductionLayer::create_layer().

add_reorg_node()

NodeID add_reorg_node ( Graph &  g, NodeParams  params, NodeIdxPair  input, int  stride  )

static

Adds a reorg layer node to the graph.

Parameters

[in]	g	Graph to add the node to
[in]	params	Common node parameters
[in]	input	Input to the reorg layer node as a NodeID-Index pair
[in]	stride	Stride value to use for reorganizing the values in the output tensor.

Returns

Node ID of the created node, EmptyNodeID in case of error

Definition at line 651 of file GraphBuilder.cpp.

{
    return create_simple_single_input_output_node<ReorgLayerNode>(g, params, input, stride);
}

References arm_compute::test::validation::input.

Referenced by ReorgLayer::create_layer().

add_reshape_node()

NodeID add_reshape_node ( Graph &  g, NodeParams  params, NodeIdxPair  input, TensorShape  shape  )

static

Adds a reshape layer node to the graph.

Parameters

[in]	g	Graph to add the node to
[in]	params	Common node parameters
[in]	input	Input to the reshape layer node as a NodeID-Index pair
[in]	shape	Output reshaped shape

Returns

Node ID of the created node, EmptyNodeID in case of error

Definition at line 656 of file GraphBuilder.cpp.

{
    return create_simple_single_input_output_node<ReshapeLayerNode>(g, params, input, shape);
}

References arm_compute::test::validation::input, and arm_compute::test::validation::shape.

Referenced by ReshapeLayer::create_layer().

add_resize_node()

NodeID add_resize_node ( Graph &  g, NodeParams  params, NodeIdxPair  input, InterpolationPolicy  policy, float  width_scale, float  height_scale  )

static

Adds a resize layer node to the graph.

Parameters

[in]	g	Graph to add the node to
[in]	params	Common node parameters
[in]	input	Input to the reshape layer node as a NodeID-Index pair
[in]	policy	Interpolation policy
[in]	width_scale	Width scaling factor
[in]	height_scale	Height scaling factor

Returns

Node ID of the created node, EmptyNodeID in case of error

Definition at line 661 of file GraphBuilder.cpp.

{
    return create_simple_single_input_output_node<ResizeLayerNode>(g, params, input, policy, width_scale, height_scale);
}

References arm_compute::test::validation::input.

Referenced by ResizeLayer::create_layer().

add_roi_align_node()

NodeID add_roi_align_node ( Graph &  g, NodeParams  params, NodeIdxPair  input, NodeIdxPair  rois, ROIPoolingLayerInfo  pool_info  )

static

Adds a ROI align layer node to the graph.

Parameters

[in]	g	Graph to add the node to
[in]	params	Common node parameters
[in]	input	Input to the reshape layer node as a NodeID-Index pair
[in]	rois	Input containing the ROIs.
[in]	pool_info	Contains pooling operation information described in ROIPoolingLayerInfo.

Returns

Node ID of the created node, EmptyNodeID in case of error

Definition at line 667 of file GraphBuilder.cpp.

{
    check_nodeidx_pair(input, g);
    check_nodeidx_pair(rois, g);
 
    NodeID nid = g.add_node<ROIAlignLayerNode>(pool_info);
 
    g.add_connection(input.node_id, input.index, nid, 0);
    g.add_connection(rois.node_id, rois.index, nid, 1);
 
    set_node_params(g, nid, params);
    return nid;
}

References Graph::add_connection(), Graph::add_node(), NodeIdxPair::index, arm_compute::test::validation::input, and NodeIdxPair::node_id.

Referenced by ROIAlignLayer::create_layer().

add_scale_layer()

NodeID add_scale_layer ( Graph &  g, const NodeParams &  params, NodeIdxPair  input, ITensorAccessorUPtr  mul_accessor = nullptr, ITensorAccessorUPtr  add_accessor = nullptr  )

static

Adds a scale layer node to the graph This layer computes a product of the input with a scale (read from mul_accessor) and it applies an offset (read from add_accessor).

output = input * mul_w + add_w

Parameters

[in]	g	Graph to add the layer to
[in]	params	Common node parameters
[in]	input	Input to the fully connected layer node as a NodeID-Index pair
[in]	mul_accessor	(Optional) Accessor of the mul node data
[in]	add_accessor	(Optional) Accessor of the add node data

Returns

Node ID of the created node, EmptyNodeID in case of error

Definition at line 681 of file GraphBuilder.cpp.

{
    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]);
    const DataLayout       input_data_layout = input_tensor_desc.layout;
 
    // Create mul node
    TensorDescriptor mul_desc = input_tensor_desc;
    const size_t     C        = input_tensor_desc.shape[get_dimension_idx(input_data_layout, DataLayoutDimension::CHANNEL)];
    mul_desc.shape.set(get_dimension_idx(input_data_layout, DataLayoutDimension::WIDTH), 1);
    mul_desc.shape.set(get_dimension_idx(input_data_layout, DataLayoutDimension::HEIGHT), 1);
    mul_desc.shape.set(get_dimension_idx(input_data_layout, 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;
}

References arm_compute::graph::Add, GraphBuilder::add_elementwise_node(), arm_compute::CHANNEL, arm_compute::graph::get_dimension_idx(), arm_compute::graph::get_tensor_descriptor(), arm_compute::HEIGHT, arm_compute::test::validation::input, TensorDescriptor::layout, arm_compute::graph::Mul, Graph::node(), INode::outputs(), TensorShape::set(), TensorDescriptor::shape, and arm_compute::WIDTH.

Referenced by ScaleLayer::create_layer().

add_slice_node()

NodeID add_slice_node ( Graph &  g, NodeParams  params, NodeIdxPair  input, Coordinates &  starts, Coordinates &  ends  )

static

Adds a slice node to the graph.

Parameters

[in]	g	Graph to add the node to
[in]	params	Common node parameters
[in]	input	Input to the slice layer node as a NodeID-Index pair
[in]	starts	The starts of the dimensions of the input tensor to be sliced. The length must be of rank(input).
[in]	ends	The ends of the dimensions of the input tensor to be sliced. The length must be of rank(input).

Returns

Node ID of the created node, EmptyNodeID in case of error

Definition at line 716 of file GraphBuilder.cpp.

{
    return create_simple_single_input_output_node<SliceLayerNode>(g, params, input, starts, ends);
}

References arm_compute::test::validation::input.

Referenced by SliceLayer::create_layer().

add_softmax_node()

NodeID add_softmax_node ( Graph &  g, NodeParams  params, NodeIdxPair  input, float  beta = 1.f  )

static

Adds a softmax node to the graph.

Parameters

[in]	g	Graph to add the node to
[in]	params	Common node parameters
[in]	input	Input to the softmax layer node as a NodeID-Index pair
[in]	beta	Beta parameter

Returns

Node ID of the created node, EmptyNodeID in case of error

Definition at line 711 of file GraphBuilder.cpp.

{
    return create_simple_single_input_output_node<SoftmaxLayerNode>(g, params, input, beta);
}

References arm_compute::test::validation::input.

Referenced by SoftmaxLayer::create_layer().

add_split_node()

NodeID add_split_node ( Graph &  g, NodeParams  params, NodeIdxPair  input, unsigned int  num_splits, unsigned int  axis = 0  )

static

Adds a split node to the graph.

Parameters

[in]	g	Graph to add the node to
[in]	params	Common node parameters
[in]	input	Input to the split layer node as a NodeID-Index pair
[in]	num_splits	Number of different splits
[in]	axis	(Optional) Split axis. Defaults to 0

Returns

Node ID of the created node, EmptyNodeID in case of error

Definition at line 721 of file GraphBuilder.cpp.

{
    return create_simple_single_input_output_node<SplitLayerNode>(g, params, input, num_splits, axis);
}

References arm_compute::test::validation::input.

add_stack_node()

NodeID add_stack_node ( Graph &  g, NodeParams  params, const std::vector< NodeIdxPair > &  inputs, int  axis  )

static

Adds a stack layer node to the graph.

Parameters

[in]	g	Graph to add the node to
[in]	params	Common node parameters
[in]	inputs	Inputs to the reorg layer node as a NodeID-Index pair
[in]	axis	Axis along which the input tensors have to be packed

Returns

Node ID of the created node, EmptyNodeID in case of error

Definition at line 731 of file GraphBuilder.cpp.

{
    return create_simple_multiple_input_single_output_node<StackLayerNode>(g, params, inputs, inputs.size(), axis);
}

Referenced by StackLayer::create_layer().

add_strided_slice_node()

NodeID add_strided_slice_node ( Graph &  g, NodeParams  params, NodeIdxPair  input, Coordinates &  starts, Coordinates &  ends, BiStrides &  strides, StridedSliceLayerInfo  info  )

static

Adds a strided slice node to the graph.

Parameters

[in]	g	Graph to add the node to
[in]	params	Common node parameters
[in]	input	Input to the strided slice layer node as a NodeID-Index pair
[in]	starts	The starts of the dimensions of the input tensor to be sliced. The length must be of rank(input).
[in]	ends	The ends of the dimensions of the input tensor to be sliced. The length must be of rank(input).
[in]	strides	The strides of the dimensions of the input tensor to be sliced. The length must be of rank(input).
[in]	info	Contains masks for the starts, ends and strides

Returns

Node ID of the created node, EmptyNodeID in case of error

Definition at line 726 of file GraphBuilder.cpp.

{
    return create_simple_single_input_output_node<StridedSliceLayerNode>(g, params, input, starts, ends, strides, info);
}

References arm_compute::test::validation::info, and arm_compute::test::validation::input.

Referenced by StridedSliceLayer::create_layer().

add_yolo_node()

NodeID add_yolo_node ( Graph &  g, NodeParams  params, NodeIdxPair  input, ActivationLayerInfo  act_info  )

static

Adds a yolo layer to the graph.

Parameters

[in]	g	Graph to add the node to
[in]	params	Common node parameters
[in]	input	Input to the yolo layer node as a NodeID-Index pair
[in]	act_info	Activation layer parameters

Returns

Node ID of the created node, EmptyNodeID in case of error

Definition at line 736 of file GraphBuilder.cpp.

{
    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]);
    const bool             is_nhwc           = input_tensor_desc.layout == DataLayout::NHWC;
 
    // Box format: [Objectness:1][Box:4][Classes:N]
 
    // Activate objectness and front part of the box
    const Coordinates box_start(0, 0, 0);
    const Coordinates box_end = is_nhwc ? Coordinates(3, -1, -1) : Coordinates(-1, -1, 3);
    NodeID            box     = g.add_node<SliceLayerNode>(box_start, box_end);
    NodeID            act_box = g.add_node<ActivationLayerNode>(act_info);
    set_node_params(g, box, params);
    set_node_params(g, act_box, params);
    g.add_connection(input.node_id, input.index, box, 0);
    g.add_connection(box, 0, act_box, 0);
 
    // Immutable part
    const Coordinates imm_start = is_nhwc ? Coordinates(3, 0, 0) : Coordinates(0, 0, 3);
    const Coordinates imm_end   = is_nhwc ? Coordinates(5, -1, -1) : Coordinates(-1, -1, 5);
    NodeID            imm       = g.add_node<SliceLayerNode>(imm_start, imm_end);
    set_node_params(g, imm, params);
    g.add_connection(input.node_id, input.index, imm, 0);
 
    // Activation classes and end part of box
    const Coordinates cls_start = is_nhwc ? Coordinates(5, 0, 0) : Coordinates(0, 0, 5);
    const Coordinates cls_end   = Coordinates(-1, -1, -1);
    NodeID            cls       = g.add_node<SliceLayerNode>(cls_start, cls_end);
    NodeID            cls_act   = g.add_node<ActivationLayerNode>(act_info);
    set_node_params(g, cls, params);
    set_node_params(g, cls_act, params);
    g.add_connection(input.node_id, input.index, cls, 0);
    g.add_connection(cls, 0, cls_act, 0);
 
    NodeID concat = g.add_node<ConcatenateLayerNode>(3, descriptors::ConcatLayerDescriptor(DataLayoutDimension::CHANNEL));
    set_node_params(g, concat, params);
    g.add_connection(act_box, 0, concat, 0);
    g.add_connection(imm, 0, concat, 1);
    g.add_connection(cls_act, 0, concat, 2);
 
    return concat;
}

References arm_compute::test::validation::act_info, Graph::add_connection(), Graph::add_node(), arm_compute::CHANNEL, arm_compute::test::framework::dataset::concat(), arm_compute::graph::get_tensor_descriptor(), arm_compute::test::validation::input, TensorDescriptor::layout, arm_compute::NHWC, Graph::node(), and INode::outputs().

Referenced by YOLOLayer::create_layer().

---

The documentation for this class was generated from the following files:

• arm_compute/graph/GraphBuilder.h
• src/graph/GraphBuilder.cpp