arm_compute::misc::shape_calculator Namespace Reference

Functions
TensorShape	calculate_reduce_mean_shape (ITensorInfo *input, const Coordinates &reduction_axis, bool keep_dims)
	Calculate the output tensor shape for the reduce mean operation. More...
TensorShape	compute_vector_to_tensor_output_shape (const TensorShape &input, size_t conv_w, size_t conv_h, const DataLayout &data_layout)
	Calculate the output tensor shape of a vector input given the convolution dimensions. More...
TensorShape	compute_permutation_output_shape (const ITensorInfo &input, const PermutationVector &perm)
	Calculate the permuted shape of an input given a permutation vector. More...
TensorShape	compute_reorg_output_shape (const ITensorInfo &input, int32_t stride)
	Calculate the output shape of the reorg layer given a stride. More...
TensorShape	compute_weights_reshaped_shape (const ITensorInfo &weights, bool has_bias=false, unsigned int num_groups=1)
	Calculate the reshaped shape of the weights. More...
TensorShape	compute_lhs_reshaped_shape (const ITensorInfo &a, const GEMMLHSMatrixInfo &lhs_info, bool reinterpret_input_as_3d=false)
	Calculate the Left Hand Side matrix reshaped shape. More...
TensorShape	compute_rhs_reshaped_shape (const ITensorInfo &a, const GEMMRHSMatrixInfo &rhs_info)
	Calculate the Right Hand Side matrix reshaped shape. More...
TensorShape	compute_interleaved_shape (const ITensorInfo &a, int mult_interleave4x4_height=1, bool reinterpret_input_as_3d=false)
	Calculate the interleaved shape of an input tensor. More...
TensorShape	compute_transpose1xW_shape (const ITensorInfo &b)
	Calculate the transposed 1xW shape. More...
TensorShape	compute_transpose1xW_with_element_size_shape (const ITensorInfo &b, int mult_transpose1xW_width=1)
	Calculate the transposed 1xW width element shape. More...
TensorShape	compute_reductionA_shape (const ITensorInfo &b)
	Calculate the reductionA shape used in GEMMLowp. More...
TensorShape	compute_reductionB_shape (const ITensorInfo &a)
	Calculate the reductionB shape used in GEMMLowp. More...
TensorShape	compute_col2im_shape (const ITensorInfo &input, const Size2D &convolved_dims, bool batch_size_on_z, unsigned int num_groups=1)
	Calculate the Col2Im shape. More...
TensorShape	compute_transposed_shape (const ITensorInfo &input)
	Calculate the transposed shape of a tensor. More...
TensorShape	compute_depthwise_convolution_shape (const ITensorInfo &input, const ITensorInfo &weights, const ConvolutionInfo &info)
	Calculate the depthwise convolution output shape of a tensor. More...
TensorShape	compute_deconvolution_upsampled_shape (const ITensorInfo &input, const ITensorInfo &weights, unsigned int sx, unsigned int sy, std::pair< unsigned int, unsigned int > &out_dims, uint32_t &padx, uint32_t &pady)
	Calculate the upsampled output shape used for deconvolution. More...
TensorShape	compute_deconvolution_output_shape (const std::pair< unsigned int, unsigned int > &out_dims, const ITensorInfo &input, const ITensorInfo &weights)
	Calculate the output shape of the deconvolution layer. More...
TensorShape	compute_im2col_conv_shape (const ITensorInfo *input, const Size2D &kernel_dims, const PadStrideInfo &conv_info, bool has_bias, const Size2D &dilation, bool batch_size_on_z, unsigned int num_groups=1, unsigned int input_pad_right=0)
	Calculate the im2col output shape of a tensor. More...
TensorShape	compute_flatten_shape (const ITensorInfo *input)
	Calculate the flattened output shape of a tensor. More...
TensorShape	compute_softmax_shape (const ITensorInfo *input, size_t axis=1)
	Calculate the softmax output shape of a tensor. More...
TensorShape	compute_winograd_filter_transform_shape (const ITensorInfo &input, const WinogradInfo &winograd_info)
	Calculate the winograd filter transform shape. More...
TensorShape	compute_winograd_input_transform_shape (const ITensorInfo &input, const WinogradInfo &winograd_info)
	Calculate the winograd input transform shape. More...
TensorShape	compute_winograd_output_transform_shape (const ITensorInfo &input, const WinogradInfo &winograd_info)
	Calculate the winograd output transform shape. More...
TensorShape	compute_deep_convolution_shape (const TensorShape &input_shape, DataLayout input_data_layout, const TensorShape &weights_shape, const PadStrideInfo &conv_info)
	Calculate the deep convolution shape output shape of a tensor. More...
TensorShape	compute_deep_convolution_shape (const ITensorInfo &input, const ITensorInfo &weights, const PadStrideInfo &conv_info)
	Calculate the deep convolution shape output shape of a tensor. More...
TensorShape	compute_indirect_buffer_shape (const TensorShape &input_shape, DataLayout input_data_layout, const TensorShape &weights_shape, const PadStrideInfo &conv_info, const DirectConvComputeKernelInfo &desc)
	Calculate the indirect buffer output shape used by the indirect convolution function. More...
TensorShape	compute_min_max_shape (const ITensorInfo *input)
	Calculate the min/max shape output shape of a tensor. More...
TensorShape	compute_pool_shape (const ITensorInfo &input, PoolingLayerInfo pool_info)
	Calculate the output pool shape of a tensor. More...
TensorShape	compute_unpool_shape (const ITensorInfo &input, PoolingLayerInfo pool_info)
	Calculate the output unpool shape of a tensor. More...
TensorShape	compute_roi_align_shape (const ITensorInfo &input, const ITensorInfo &rois, ROIPoolingLayerInfo pool_info)
	Calculate the output roi align shape of a tensor. More...
TensorShape	compute_rnn_shape (const ITensorInfo *input, const unsigned int batch_size)
	Calculate the RNN shape of a tensor. More...
TensorShape	compute_mm_shape (const ITensorInfo &input0, const ITensorInfo &input1, bool is_interleaved_transposed, const GEMMReshapeInfo &reshape_info)
	Calculate the matrix multiplication output shape of two tensors. More...
TensorShape	compute_mm_shape (const ITensorInfo &input0, const ITensorInfo &input1, const GEMMReshapeInfo &gemm_info)
	Calculate the matrix multiplication output shape of two tensors. More...
TensorShape	compute_mm_shape (const ITensorInfo &input0, const ITensorInfo &input1, const GEMMKernelInfo &gemm_info)
	Calculate the matrix multiplication output shape of two tensors. More...
TensorShape	compute_matmul_shape (const TensorShape &input0, const TensorShape &input1, const MatMulKernelInfo &matmul_info)
	Calculate the matrix multiplication output shape of two tensors. More...
TensorShape	compute_output_stage_shape (const ITensorInfo &input, unsigned int gemm_3d_depth=1, bool batch_size_on_z=false)
	Calculate the matrix multiplication output shape of two tensors. More...
TensorShape	compute_strided_slice_shape (const ITensorInfo &input, const Coordinates &starts, const Coordinates &ends, const Coordinates &strides, int32_t begin_mask, int32_t end_mask, int32_t shrink_axis_mask)
	Calculate the strided slice output shape of a tensor. More...
TensorShape	compute_slice_shape (const TensorShape &input_shape, const Coordinates &starts, const Coordinates &ends)
	Calculate the slice output shape of a tensor. More...
TensorShape	compute_batch_to_space_shape (DataLayout data_layout, const TensorShape &input, int block_x, int block_y, const CropInfo &crop_info=CropInfo{})
	Calculate the batch to space output shape of a tensor. More...
TensorShape	compute_depth_to_space_shape (const TensorShape &input_shape, DataLayout data_layout, int block)
	Calculate the depth to space output shape of a tensor. More...
TensorShape	compute_split_shape (const ITensorInfo *input, unsigned int axis, unsigned int num_splits)
	Calculate the split output shape of a tensor. More...
TensorShape	compute_space_to_batch_shape (const ITensorInfo *input, int block_x, int block_y, const Size2D &padding_left, const Size2D &padding_right)
	Calculate the space to batch output shape of a tensor. More...
TensorShape	compute_space_to_depth_shape (const ITensorInfo *input, int32_t block_shape)
	Calculate the space to batch output shape of a tensor. More...
TensorShape	compute_prior_box_shape (const ITensorInfo &input, const PriorBoxLayerInfo &info)
	Calculate the prior box output shape of a tensor. More...
TensorShape	compute_padded_shape (const TensorShape &input_shape, const PaddingList &padding)
	Calculate the padded shape of a tensor. More...
TensorShape	compute_tiled_shape (const TensorShape &input_shape, const Multiples &multiples)
	Calculate the tiled shape of a tensor. More...
TensorShape	compute_reduced_shape (const TensorShape &input, unsigned int axis, bool keep_dims=true)
	Calculate the reduced shape of a tensor given an axis. More...
TensorShape	compute_upsample_shape (const ITensorInfo &input, const Size2D &info)
	Calculate the upsampled shape of a tensor. More...
template<typename T >
TensorShape	extract_shape (T *data)
	Get the tensor shape. More...
TensorShape	extract_shape (ITensorInfo *data)
TensorShape	extract_shape (const ITensorInfo *data)
TensorShape	extract_shape (const TensorShape *data)
TensorShape	extract_shape (TensorShape *data)
TensorShape	calculate_unstack_shape (TensorShape input_shape, unsigned int axis)
	Calculate the unstack shape of a tensor. More...
template<typename T >
TensorShape	calculate_concatenate_shape (const std::vector< T * > &input, size_t axis)
	Calculate the concatenate output shape of the concatenate operation along a single axis. More...
TensorShape	compute_stack_shape (const ITensorInfo &a, unsigned int axis, unsigned int num_tensors)
	Calculate the stack output shape of a tensor. More...
TensorShape	compute_conv3d_shape (const TensorShape &src, const TensorShape &weights, const Conv3dInfo &conv3d_info)
	Calculate the output shape of 3d Convolution. More...
TensorShape	compute_pool3d_shape (const TensorShape &src, Pooling3dLayerInfo pool3d_info)
	Calculate the output pool3d shape of a tensor. More...
TensorShape	compute_gather_shape (const TensorShape &input_shape, const TensorShape &indices_shape, uint32_t actual_axis)
	Calculate the gather output shape of a tensor. More...

Function Documentation

calculate_concatenate_shape()

TensorShape arm_compute::misc::shape_calculator::calculate_concatenate_shape ( const std::vector< T * > &  input, size_t  axis  )

inline

Calculate the concatenate output shape of the concatenate operation along a single axis.

Parameters

[in]	input	Vector containing the shapes of the inputs
[in]	axis	Axis along which to concatenate the input tensors

Returns

the calculated shape

Definition at line 1404 of file ShapeCalculator.h.

{
    TensorShape out_shape = extract_shape(input[0]);
 
#if defined(ARM_COMPUTE_ASSERTS_ENABLED)
    // All dimensions must match except the axis one
    for(unsigned int i = 0; i < MAX_DIMS; ++i)
    {
        if(i == axis)
        {
            continue;
        }
 
        for(const auto &tensor : input)
        {
            ARM_COMPUTE_ERROR_ON(tensor == nullptr);
            const TensorShape shape = extract_shape(tensor);
            ARM_COMPUTE_ERROR_ON(out_shape[i] != shape[i]);
        }
    }
#endif // defined(ARM_COMPUTE_ASSERTS_ENABLED)
 
    // Calculate output shape
    size_t new_size = 0;
    for(const auto &tensor : input)
    {
        const TensorShape shape = extract_shape(tensor);
        new_size += shape[axis];
    }
 
    out_shape.set(axis, new_size);
 
    return out_shape;
}

References ARM_COMPUTE_ERROR_ON, extract_shape(), arm_compute::test::validation::input, arm_compute::MAX_DIMS, TensorShape::set(), arm_compute::test::validation::shape, and tensor.

Referenced by ConcatenateLayerNode::compute_output_descriptor(), CpuConcatenate::configure(), ClConcatenate::configure(), CLLSTMLayer::configure(), CpuConcatenate::validate(), ClConcatenate::validate(), NELSTMLayer::validate(), and CLLSTMLayer::validate().

calculate_reduce_mean_shape()

TensorShape arm_compute::misc::shape_calculator::calculate_reduce_mean_shape ( ITensorInfo *  input, const Coordinates &  reduction_axis, bool  keep_dims  )

inline

Calculate the output tensor shape for the reduce mean operation.

Parameters

[in]	input	Input tensor shape
[in]	reduction_axis	Reduction axis
[in]	keep_dims	Flag to indicate if dimensions are kept

Returns

the calculated shape

Definition at line 52 of file ShapeCalculator.h.

{
    const int   reduction_ops = reduction_axis.num_dimensions();
    Coordinates axis_local    = reduction_axis;
    const int   input_dims    = input->num_dimensions();
    convert_negative_axis(axis_local, input_dims);
    TensorShape out_shape = input->tensor_shape();
    // Configure reshape layer if we want to drop the dimensions
    if(!keep_dims)
    {
        // We have to sort the reduction axis vectors in order for remove_dimension
        // to work properly
        std::sort(axis_local.begin(), axis_local.begin() + reduction_ops);
        for(int i = 0; i < reduction_ops; ++i)
        {
            out_shape.remove_dimension(axis_local[i] - i, false);
        }
        return out_shape;
    }
    else
    {
        for(int i = 0; i < reduction_ops; ++i)
        {
            out_shape.set(axis_local[i], 1);
        }
        return out_shape;
    }
}

References Dimensions< T >::begin(), arm_compute::convert_negative_axis(), arm_compute::test::validation::input, Dimensions< T >::num_dimensions(), TensorShape::remove_dimension(), and TensorShape::set().

Referenced by NEReduceMean::configure(), and CLReduceMean::configure().

calculate_unstack_shape()

TensorShape arm_compute::misc::shape_calculator::calculate_unstack_shape ( TensorShape  input_shape, unsigned int  axis  )

inline

Calculate the unstack shape of a tensor.

Parameters

[in]	input_shape	Input tensor shape
[in]	axis	Axis on which to perform the unstack operation

Returns

the calculated shape

Definition at line 1389 of file ShapeCalculator.h.

{
    ARM_COMPUTE_ERROR_ON(axis > input_shape.num_dimensions());
    input_shape.remove_dimension(axis);
    return input_shape;
}

References ARM_COMPUTE_ERROR_ON, and arm_compute::test::validation::input_shape.

compute_batch_to_space_shape()

TensorShape arm_compute::misc::shape_calculator::compute_batch_to_space_shape ( DataLayout  data_layout, const TensorShape &  input, int  block_x, int  block_y, const CropInfo &  crop_info = CropInfo{}  )

inline

Calculate the batch to space output shape of a tensor.

Parameters

[in]	data_layout	Data layout
[in]	input	Input tensor shape
[in]	block_x	Block shape x value
[in]	block_y	Block shape y value
[in]	crop_info	Information about how the output shape is cropped after batch to space is performed

Returns

the calculated shape

Definition at line 1113 of file ShapeCalculator.h.

                                                                                                                                                                {})
{
    ARM_COMPUTE_ERROR_ON(block_x < 1 || block_y < 1);
 
    const int idx_width  = get_data_layout_dimension_index(data_layout, DataLayoutDimension::WIDTH);
    const int idx_height = get_data_layout_dimension_index(data_layout, DataLayoutDimension::HEIGHT);
    const int idx_batch  = get_data_layout_dimension_index(data_layout, DataLayoutDimension::BATCHES);
 
    TensorShape output_shape{ input };
 
    unsigned int       new_width   = input[idx_width] * static_cast<unsigned int>(block_x);
    unsigned int       new_height  = input[idx_height] * static_cast<unsigned int>(block_y);
    const unsigned int width_crop  = crop_info.left + crop_info.right;
    const unsigned int height_crop = crop_info.top + crop_info.bottom;
    ARM_COMPUTE_ERROR_ON(new_width <= width_crop);
    ARM_COMPUTE_ERROR_ON(new_height <= height_crop);
    new_width -= width_crop;
    new_height -= height_crop;
 
    output_shape.set(idx_width, new_width);
    output_shape.set(idx_height, new_height);
    output_shape.set(idx_batch, input[idx_batch] / (block_x * block_y));
 
    return output_shape;
}

Referenced by arm_compute::test::validation::reference::batch_to_space(), NEBatchToSpaceLayerKernel::configure(), and CLBatchToSpaceLayerKernel::configure().

compute_col2im_shape()

TensorShape arm_compute::misc::shape_calculator::compute_col2im_shape ( const ITensorInfo &  input, const Size2D &  convolved_dims, bool  batch_size_on_z, unsigned int  num_groups = 1  )

inline

Calculate the Col2Im shape.

Parameters

[in]	input	Input tensor info
[in]	convolved_dims	Convolved dimensions
[in]	batch_size_on_z	True if batch size is on z axis
[in]	num_groups	(Optional) Number of groups when performing a grouped convolution

Returns

the calculated shape

Definition at line 373 of file ShapeCalculator.h.

{
    ARM_COMPUTE_ERROR_ON(num_groups == 0);
    ARM_COMPUTE_ERROR_ON(input.tensor_shape()[1] != (convolved_dims.area()));
    ARM_COMPUTE_ERROR_ON((num_groups > 1) && input.tensor_shape()[2] != num_groups);
 
    const DataLayout data_layout = input.data_layout();
    const int        width_idx   = get_data_layout_dimension_index(data_layout, DataLayoutDimension::WIDTH);
    const int        height_idx  = get_data_layout_dimension_index(data_layout, DataLayoutDimension::HEIGHT);
    const int        channel_idx = get_data_layout_dimension_index(data_layout, DataLayoutDimension::CHANNEL);
 
    TensorShape col2im_shape{ input.tensor_shape() };
    // If batches start on 3rd dimension shift dimensions right by 1 to retain upper tensor shape,
    // as first three will be override by H,W,C data
    if(batch_size_on_z && num_groups == 1)
    {
        col2im_shape.shift_right(1);
    }
    col2im_shape.set(width_idx, convolved_dims.width);
    col2im_shape.set(height_idx, convolved_dims.height);
    col2im_shape.set(channel_idx, input.tensor_shape()[0] * num_groups);
 
    return col2im_shape;
}

References Size2D::area(), ARM_COMPUTE_ERROR_ON, arm_compute::CHANNEL, arm_compute::test::validation::data_layout, arm_compute::get_data_layout_dimension_index(), Size2D::height, arm_compute::HEIGHT, arm_compute::test::validation::input, arm_compute::test::validation::num_groups, Size2D::width, and arm_compute::WIDTH.

Referenced by CpuCol2ImKernel::configure().

compute_conv3d_shape()

TensorShape arm_compute::misc::shape_calculator::compute_conv3d_shape ( const TensorShape &  src, const TensorShape &  weights, const Conv3dInfo &  conv3d_info  )

inline

Calculate the output shape of 3d Convolution.

Parameters

[in]	src	Input tensor shape
[in]	weights	Weights tensor shape
[in]	conv3d_info	3d Convolution Parameters object

Returns

the calculated shape

Definition at line 1476 of file ShapeCalculator.h.

{
    // Weight tensor shape indices (D H W Cin Cout)
    constexpr unsigned int weights_depth_dim  = 4u;
    constexpr unsigned int weights_height_dim = 3u;
    constexpr unsigned int weights_width_dim  = 2u;
    constexpr unsigned int weights_CHout_dim  = 0u;
 
    // Source/Destination Tensor shape indices (N D H W C)
    constexpr unsigned int batch_dim   = 4u;
    constexpr unsigned int depth_dim   = 3u;
    constexpr unsigned int height_dim  = 2u;
    constexpr unsigned int width_dim   = 1u;
    constexpr unsigned int channel_dim = 0u;
 
    TensorShape  output_shape{ src };
    const size_t pad_left   = conv3d_info.padding.left;
    const size_t pad_right  = conv3d_info.padding.right;
    const size_t pad_top    = conv3d_info.padding.top;
    const size_t pad_bottom = conv3d_info.padding.bottom;
    const size_t pad_front  = conv3d_info.padding.front;
    const size_t pad_back   = conv3d_info.padding.back;
    const size_t dilation_x = conv3d_info.dilation.width;
    const size_t dilation_y = conv3d_info.dilation.height;
    const size_t dilation_z = conv3d_info.dilation.depth;
    const size_t stride_x   = conv3d_info.stride.x();
    const size_t stride_y   = conv3d_info.stride.y();
    const size_t stride_z   = conv3d_info.stride.z();
 
    int output_width_size  = 0;
    int output_height_size = 0;
    int output_depth_size  = 0;
 
    switch(conv3d_info.round_type)
    {
        case DimensionRoundingType::FLOOR:
            output_width_size  = static_cast<int>(std::floor((static_cast<float>(src[width_dim] + pad_left + pad_right - (dilation_x * (weights[weights_width_dim] - 1) + 1)) / stride_x) + 1));
            output_height_size = static_cast<int>(std::floor((static_cast<float>(src[height_dim] + pad_top + pad_bottom - (dilation_y * (weights[weights_height_dim] - 1) + 1)) / stride_y) + 1));
            output_depth_size  = static_cast<int>(std::floor((static_cast<float>(src[depth_dim] + pad_front + pad_back - (dilation_z * (weights[weights_depth_dim] - 1) + 1)) / stride_z) + 1));
            break;
        case DimensionRoundingType::CEIL:
            output_width_size  = static_cast<int>(std::ceil((static_cast<float>(src[width_dim] + pad_left + pad_right - (dilation_x * (weights[weights_width_dim] - 1) + 1)) / stride_x) + 1));
            output_height_size = static_cast<int>(std::ceil((static_cast<float>(src[height_dim] + pad_top + pad_bottom - (dilation_y * (weights[weights_height_dim] - 1) + 1)) / stride_y) + 1));
            output_depth_size  = static_cast<int>(std::ceil((static_cast<float>(src[depth_dim] + pad_front + pad_back - (dilation_z * (weights[weights_depth_dim] - 1) + 1)) / stride_z) + 1));
            break;
        default:
            ARM_COMPUTE_ERROR("Unsupported rounding type");
    }
 
    output_shape.set(batch_dim, src[batch_dim]);
    output_shape.set(width_dim, output_width_size);
    output_shape.set(height_dim, output_height_size);
    output_shape.set(depth_dim, output_depth_size);
    output_shape.set(channel_dim, weights[weights_CHout_dim]);
    return output_shape;
}

References ARM_COMPUTE_ERROR, Padding3D::back, batch_dim, Padding3D::bottom, arm_compute::CEIL, channel_dim, Size3D::depth, depth_dim, Conv3dInfo::dilation, arm_compute::FLOOR, Padding3D::front, Size3D::height, height_dim, Padding3D::left, arm_compute::test::validation::output_shape, Conv3dInfo::padding, Padding3D::right, Conv3dInfo::round_type, arm_compute::test::validation::src, Conv3dInfo::stride, Padding3D::top, weights_CHout_dim, weights_depth_dim, weights_height_dim, weights_width_dim, Size3D::width, width_dim, Size3D::x(), Size3D::y(), and Size3D::z().

Referenced by CpuDirectConv3dKernel::configure(), and arm_compute::test::validation::reference::conv3d().

compute_deconvolution_output_shape()

TensorShape arm_compute::misc::shape_calculator::compute_deconvolution_output_shape ( const std::pair< unsigned int, unsigned int > &  out_dims, const ITensorInfo &  input, const ITensorInfo &  weights  )

inline

Calculate the output shape of the deconvolution layer.

Parameters

[in]	out_dims	Output x and y shape dimensions
[in]	input	Input tensor info
[in]	weights	Weights tensor shape

Returns

the calculated shape

Definition at line 494 of file ShapeCalculator.h.

{
    const TensorShape input_shape{ input.tensor_shape() };
    const TensorShape weights_shape{ weights.tensor_shape() };
 
    const DataLayout data_layout = input.data_layout();
    const int        width_idx   = get_data_layout_dimension_index(data_layout, DataLayoutDimension::WIDTH);
    const int        height_idx  = get_data_layout_dimension_index(data_layout, DataLayoutDimension::HEIGHT);
    const int        channel_idx = get_data_layout_dimension_index(data_layout, DataLayoutDimension::CHANNEL);
    const int        batch_idx   = get_data_layout_dimension_index(data_layout, DataLayoutDimension::BATCHES);
 
    TensorShape out_shape{ input_shape };
    out_shape.set(width_idx, out_dims.first);
    out_shape.set(height_idx, out_dims.second);
    out_shape.set(channel_idx, weights_shape[batch_idx]);
    return out_shape;
}

References arm_compute::BATCHES, arm_compute::CHANNEL, arm_compute::test::validation::data_layout, arm_compute::get_data_layout_dimension_index(), arm_compute::HEIGHT, arm_compute::test::validation::input, arm_compute::test::validation::input_shape, ITensorInfo::tensor_shape(), arm_compute::test::validation::weights_shape, and arm_compute::WIDTH.

Referenced by ClTransposedConvolutionKernel::configure(), NEDeconvolutionLayer::configure(), CLDirectDeconvolutionLayer::configure(), NEDeconvolutionLayer::validate(), CLGEMMDeconvolutionLayer::validate(), and CLDirectDeconvolutionLayer::validate().

compute_deconvolution_upsampled_shape()

TensorShape arm_compute::misc::shape_calculator::compute_deconvolution_upsampled_shape ( const ITensorInfo &  input, const ITensorInfo &  weights, unsigned int  sx, unsigned int  sy, std::pair< unsigned int, unsigned int > &  out_dims, uint32_t &  padx, uint32_t &  pady  )

inline

Calculate the upsampled output shape used for deconvolution.

Parameters

[in]	input	Input tensor info
[in]	weights	Weights tensor shape
[in]	sx	Stride on x axis
[in]	sy	Stride on y axis
[in]	out_dims	Output shape dimensions
[in]	padx	Padding on x axis
[in]	pady	Padding on y axis

Returns

the calculated shape

Definition at line 462 of file ShapeCalculator.h.

{
    const DataLayout data_layout = input.data_layout();
    const size_t     idx_w       = get_data_layout_dimension_index(data_layout, DataLayoutDimension::WIDTH);
    const size_t     idx_h       = get_data_layout_dimension_index(data_layout, DataLayoutDimension::HEIGHT);
 
    // Find the upsampled dimensions
    unsigned int out_x = (input.dimension(idx_w) - 1) * sx + 1;
    unsigned int out_y = (input.dimension(idx_h) - 1) * sy + 1;
 
    // Find the padding needed for the convolution with stride 1 in order to match output shape
    padx = out_dims.first - (out_x - weights.dimension(idx_w) + 1);
    pady = out_dims.second - (out_y - weights.dimension(idx_h) + 1);
    out_x += padx;
    out_y += pady;
 
    TensorShape scale_out_shape(input.tensor_shape());
    scale_out_shape.set(idx_w, out_x);
    scale_out_shape.set(idx_h, out_y);
 
    return scale_out_shape;
}

References arm_compute::test::validation::data_layout, ITensorInfo::dimension(), arm_compute::get_data_layout_dimension_index(), arm_compute::HEIGHT, arm_compute::test::validation::input, TensorShape::set(), and arm_compute::WIDTH.

Referenced by NEDeconvolutionLayer::configure(), CLDirectDeconvolutionLayer::configure(), NEDeconvolutionLayer::validate(), and CLDirectDeconvolutionLayer::validate().

compute_deep_convolution_shape() [1/2]

TensorShape arm_compute::misc::shape_calculator::compute_deep_convolution_shape ( const ITensorInfo &  input, const ITensorInfo &  weights, const PadStrideInfo &  conv_info  )

inline

Calculate the deep convolution shape output shape of a tensor.

Parameters

[in]	input	Input tensor info
[in]	weights	Weights tensor info
[in]	conv_info	Contains padding and stride information

Returns

the calculated shape

Definition at line 746 of file ShapeCalculator.h.

{
    return compute_deep_convolution_shape(input.tensor_shape(), input.data_layout(), weights.tensor_shape(), conv_info);
}

References compute_deep_convolution_shape(), arm_compute::test::validation::conv_info, arm_compute::test::validation::input, and ITensorInfo::tensor_shape().

compute_deep_convolution_shape() [2/2]

TensorShape arm_compute::misc::shape_calculator::compute_deep_convolution_shape ( const TensorShape &  input_shape, DataLayout  input_data_layout, const TensorShape &  weights_shape, const PadStrideInfo &  conv_info  )

inline

Calculate the deep convolution shape output shape of a tensor.

Parameters

[in]	input_shape	Input tensor shape
[in]	input_data_layout	Input data layout
[in]	weights_shape	Weights tensor shape
[in]	conv_info	Contains padding and stride information

Returns

the calculated shape

Definition at line 715 of file ShapeCalculator.h.

{
    const size_t idx_width   = get_data_layout_dimension_index(input_data_layout, DataLayoutDimension::WIDTH);
    const size_t idx_height  = get_data_layout_dimension_index(input_data_layout, DataLayoutDimension::HEIGHT);
    const size_t idx_channel = get_data_layout_dimension_index(input_data_layout, DataLayoutDimension::CHANNEL);
 
    const unsigned int input_width         = input_shape[idx_width];
    const unsigned int input_height        = input_shape[idx_height];
    const unsigned int weights_width       = weights_shape[idx_width];
    const unsigned int weights_height      = weights_shape[idx_height];
    const unsigned int weights_out_channel = weights_shape[3];
    unsigned int       output_width        = 0;
    unsigned int       output_height       = 0;
    std::tie(output_width, output_height) = scaled_dimensions(input_width, input_height, weights_width, weights_height, conv_info);
 
    TensorShape output_shape{ input_shape };
    output_shape.set(idx_width, output_width);
    output_shape.set(idx_height, output_height);
    output_shape.set(idx_channel, weights_out_channel);
 
    return output_shape;
}

References arm_compute::CHANNEL, arm_compute::test::validation::conv_info, arm_compute::get_data_layout_dimension_index(), arm_compute::HEIGHT, arm_compute::test::validation::idx_height, arm_compute::test::validation::idx_width, input_height, arm_compute::test::validation::input_shape, input_width, arm_compute::test::validation::output_shape, arm_compute::scaled_dimensions(), weights_height, arm_compute::test::validation::weights_shape, weights_width, and arm_compute::WIDTH.

Referenced by compute_deep_convolution_shape(), compute_indirect_buffer_shape(), CpuDirectConv2dKernel::configure(), ClIndirectConv2dKernel::configure(), ClIndirectConv2dAddressPrecalculationKernel::configure(), ClDirectConv2dKernel::configure(), ClConv2d::get_convolution_method(), arm_compute::test::validation::TEST_CASE(), ClComponentDirectConv2d::validate(), and arm_compute::cpu::kernels::validate_arguments().

compute_depth_to_space_shape()

TensorShape arm_compute::misc::shape_calculator::compute_depth_to_space_shape ( const TensorShape &  input_shape, DataLayout  data_layout, int  block  )

inline

Calculate the depth to space output shape of a tensor.

Parameters

[in]	input_shape	Input tensor shape
[in]	data_layout	Operation data layout
[in]	block	Block shape value

Returns

the calculated shape

Definition at line 1147 of file ShapeCalculator.h.

{
    ARM_COMPUTE_ERROR_ON(block < 2);
 
    const int idx_width   = get_data_layout_dimension_index(data_layout, DataLayoutDimension::WIDTH);
    const int idx_height  = get_data_layout_dimension_index(data_layout, DataLayoutDimension::HEIGHT);
    const int idx_channel = get_data_layout_dimension_index(data_layout, DataLayoutDimension::CHANNEL);
 
    TensorShape output_shape{ input_shape };
    output_shape.set(idx_width, input_shape[idx_width] * block);
    output_shape.set(idx_height, input_shape[idx_height] * block);
    output_shape.set(idx_channel, input_shape[idx_channel] / (block * block));
 
    return output_shape;
}

References ARM_COMPUTE_ERROR_ON, arm_compute::CHANNEL, arm_compute::test::validation::data_layout, arm_compute::get_data_layout_dimension_index(), arm_compute::HEIGHT, arm_compute::test::validation::idx_height, arm_compute::test::validation::idx_width, arm_compute::test::validation::input_shape, arm_compute::test::validation::output_shape, and arm_compute::WIDTH.

Referenced by DepthToSpaceLayerNode::compute_output_descriptor(), NEDepthToSpaceLayerKernel::configure(), and CLDepthToSpaceLayerKernel::configure().

compute_depthwise_convolution_shape()

TensorShape arm_compute::misc::shape_calculator::compute_depthwise_convolution_shape ( const ITensorInfo &  input, const ITensorInfo &  weights, const ConvolutionInfo &  info  )

inline

Calculate the depthwise convolution output shape of a tensor.

Parameters

[in]	input	Input tensor info
[in]	weights	Weights tensor info
[in]	info	Convolution info

Returns

the calculated shape

Definition at line 422 of file ShapeCalculator.h.

{
    const TensorShape input_shape{ input.tensor_shape() };
    const TensorShape weights_shape{ weights.tensor_shape() };
 
    const DataLayout data_layout = input.data_layout();
    const int        width_idx   = get_data_layout_dimension_index(data_layout, DataLayoutDimension::WIDTH);
    const int        height_idx  = get_data_layout_dimension_index(data_layout, DataLayoutDimension::HEIGHT);
    const int        channel_idx = get_data_layout_dimension_index(data_layout, DataLayoutDimension::CHANNEL);
 
    const DataLayout weights_data_layout = weights.data_layout();
    const int        weights_width_idx   = get_data_layout_dimension_index(weights_data_layout, DataLayoutDimension::WIDTH);
    const int        weights_height_idx  = get_data_layout_dimension_index(weights_data_layout, DataLayoutDimension::HEIGHT);
 
    unsigned int output_width  = 0;
    unsigned int output_height = 0;
    std::tie(output_width, output_height) = scaled_dimensions(input_shape[width_idx], input_shape[height_idx],
                                                              weights_shape[weights_width_idx], weights_shape[weights_height_idx],
                                                              info.pad_stride_info, info.dilation);
 
    TensorShape output_shape{ input_shape };
    output_shape.set(width_idx, output_width);
    output_shape.set(height_idx, output_height);
    output_shape.set(channel_idx, input_shape[channel_idx] * info.depth_multiplier);
 
    return output_shape;
}

References arm_compute::CHANNEL, ITensorInfo::data_layout(), arm_compute::test::validation::data_layout, arm_compute::get_data_layout_dimension_index(), arm_compute::HEIGHT, arm_compute::test::validation::info, arm_compute::test::validation::input, arm_compute::test::validation::input_shape, arm_compute::test::validation::output_shape, arm_compute::scaled_dimensions(), ITensorInfo::tensor_shape(), arm_compute::test::validation::weights_shape, and arm_compute::WIDTH.

Referenced by CpuDepthwiseConv2dNativeKernel::configure(), CpuDepthwiseConv2dAssemblyWrapperKernel::configure(), CLDepthwiseConvolutionLayerNativeKernel::configure(), CpuDepthwiseConv2dAssemblyWrapperKernel::validate(), CLDepthwiseConvolutionLayer::validate(), and ClComponentDepthwiseConv2d::validate().

compute_flatten_shape()

TensorShape arm_compute::misc::shape_calculator::compute_flatten_shape ( const ITensorInfo *  input )

inline

Calculate the flattened output shape of a tensor.

Parameters

[in]

input

Input tensor info

Returns

the calculated shape

Definition at line 563 of file ShapeCalculator.h.

{
    // The output shape will be the flatten version of the input (i.e. [ width * height * channels, num_batches, ... ] ). Used for FlattenLayer and FullyConnectedLayer.
 
    TensorShape output_shape{ input->tensor_shape() };
 
    output_shape.collapse(3);
 
    return output_shape;
}

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

Referenced by NEFlattenLayer::configure(), CLFlattenLayer::configure(), NEFlattenLayer::validate(), CLFlattenLayer::validate(), CpuFullyConnected::validate(), and ClFullyConnected::validate().

compute_gather_shape()

TensorShape arm_compute::misc::shape_calculator::compute_gather_shape ( const TensorShape &  input_shape, const TensorShape &  indices_shape, uint32_t  actual_axis  )

inline

Calculate the gather output shape of a tensor.

Parameters

[in]	input_shape	Input tensor shape
[in]	indices_shape	Indices tensor shape. Only supports for 2d and 3d indices
[in]	actual_axis	Axis to be used in the computation

Note

Let input_shape be (X,Y,Z) and indices shape (W,O,P) and axis 1 the new shape is computed by replacing the axis in the input shape with the indice shape so the output shape will be (X,W,O,P,Z)

Returns

the calculated shape

Definition at line 1579 of file ShapeCalculator.h.

{
    const auto input_num_dims   = input_shape.num_dimensions();
    const auto indices_num_dims = indices_shape.num_dimensions();
 
    ARM_COMPUTE_ERROR_ON(actual_axis >= input_num_dims);
    ARM_COMPUTE_ERROR_ON(input_num_dims + indices_num_dims - 1 > Coordinates::num_max_dimensions);
 
    TensorShape output_shape;
    size_t      dim_no = 0;
 
    for(; dim_no < actual_axis; ++dim_no)
    {
        output_shape.set(dim_no, input_shape[dim_no]);
    }
 
    for(; dim_no < actual_axis + indices_num_dims; ++dim_no)
    {
        output_shape.set(dim_no, indices_shape[dim_no - actual_axis]);
    }
 
    for(; dim_no < input_num_dims + indices_num_dims - 1; ++dim_no)
    {
        output_shape.set(dim_no, input_shape[dim_no + 1 - indices_num_dims]);
    }
 
    ARM_COMPUTE_ERROR_ON(input_shape.total_size() * indices_shape.total_size() != output_shape.total_size() * input_shape[actual_axis]);
 
    return output_shape;
}

References ARM_COMPUTE_ERROR_ON, arm_compute::test::validation::input_shape, Dimensions< T >::num_dimensions(), Dimensions< int >::num_max_dimensions, arm_compute::test::validation::output_shape, and TensorShape::total_size().

Referenced by NEGatherKernel::configure(), and arm_compute::test::validation::reference::gather().

compute_im2col_conv_shape()

TensorShape arm_compute::misc::shape_calculator::compute_im2col_conv_shape ( const ITensorInfo *  input, const Size2D &  kernel_dims, const PadStrideInfo &  conv_info, bool  has_bias, const Size2D &  dilation, bool  batch_size_on_z, unsigned int  num_groups = 1, unsigned int  input_pad_right = 0  )

inline

Calculate the im2col output shape of a tensor.

Parameters

[in]	input	Input tensor info
[in]	kernel_dims	The kernel dimensions (width and height).
[in]	conv_info	Contains padding and stride information
[in]	has_bias	In case biases are provided expands the matrix with 1
[in]	dilation	Dilation, in elements, across x and y
[in]	batch_size_on_z	True if batch size is on z axis
[in]	num_groups	(Optional) Number of groups when performing a grouped convolution
[in]	input_pad_right	(Optional) When fast-math is selected, per element padding for the im2col matrix may be necessary

Returns

the calculated shape

Definition at line 525 of file ShapeCalculator.h.

{
    // The output shape will be the 3D shape [ out_channels * kernel_area, num_elems_per_out_channel, batches ]                           if batch_size_on_z == true
    //                       or the 4D shape [ out_channels * kernel_area / num_groups, num_elems_per_out_channel, num_groups, batches ]  if batch_size_on_z == false
 
    ARM_COMPUTE_ERROR_ON(num_groups == 0);
    ARM_COMPUTE_ERROR_ON(num_groups > 1 && input->data_layout() != DataLayout::NCHW);
    ARM_COMPUTE_ERROR_ON(num_groups > 1 && batch_size_on_z);
 
    TensorShape output_shape{ input->tensor_shape() };
 
    const DataLayout data_layout = input->data_layout();
    const int        width_idx   = get_data_layout_dimension_index(data_layout, DataLayoutDimension::WIDTH);
    const int        height_idx  = get_data_layout_dimension_index(data_layout, DataLayoutDimension::HEIGHT);
    const int        channel_idx = get_data_layout_dimension_index(data_layout, DataLayoutDimension::CHANNEL);
 
    std::pair<unsigned int, unsigned int> out_dims = scaled_dimensions(output_shape[width_idx], output_shape[height_idx], kernel_dims.width, kernel_dims.height, conv_info, dilation);
    output_shape.set(0, ((output_shape[channel_idx] + input_pad_right) / num_groups * kernel_dims.area() + (has_bias ? 1 : 0))); // NOLINT
    output_shape.set(1, (out_dims.first * out_dims.second));
    if(batch_size_on_z && output_shape.num_dimensions() >= 3)
    {
        output_shape.remove_dimension(2);
    }
    else
    {
        output_shape.set(2, num_groups);
    }
 
    return output_shape;
}

References Size2D::area(), ARM_COMPUTE_ERROR_ON, arm_compute::CHANNEL, arm_compute::test::validation::conv_info, arm_compute::test::validation::data_layout, arm_compute::get_data_layout_dimension_index(), arm_compute::test::validation::has_bias, Size2D::height, arm_compute::HEIGHT, arm_compute::test::validation::input, arm_compute::NCHW, arm_compute::test::validation::num_groups, arm_compute::test::validation::output_shape, arm_compute::scaled_dimensions(), Size2D::width, and arm_compute::WIDTH.

Referenced by CpuIm2ColKernel::configure(), and ClGemmConv2d::validate().

compute_indirect_buffer_shape()

TensorShape arm_compute::misc::shape_calculator::compute_indirect_buffer_shape ( const TensorShape &  input_shape, DataLayout  input_data_layout, const TensorShape &  weights_shape, const PadStrideInfo &  conv_info, const DirectConvComputeKernelInfo &  desc  )

inline

Calculate the indirect buffer output shape used by the indirect convolution function.

Parameters

[in]	input_shape	Input tensor shape
[in]	input_data_layout	Input data layout
[in]	weights_shape	Weights tensor shape
[in]	conv_info	Contains padding and stride information
[in]	desc	Contains the direct/indirect convolution compute arguments, such as the tiling dimensions

Returns

the calculated shape

Definition at line 761 of file ShapeCalculator.h.

{
    ARM_COMPUTE_ERROR_ON_MSG(input_data_layout != DataLayout::NHWC, "The data layout can only be NHWC");
    ARM_COMPUTE_ERROR_ON_MSG(desc.m0 <= 0 || desc.m0 > 8, "M0 can only be greater than 0 and less than or equal to 8");
 
    const unsigned int m0 = desc.m0;
    const unsigned int kw = weights_shape[1];
    const unsigned int kh = weights_shape[2];
 
    TensorShape output_conv2d_shape = compute_deep_convolution_shape(input_shape, input_data_layout, weights_shape, conv_info);
 
    const unsigned int output_w = m0 * kw * kh;
    const unsigned int output_h = DIV_CEIL(output_conv2d_shape[1] * output_conv2d_shape[2], m0);
    const unsigned int output_b = output_conv2d_shape[3];
 
    return TensorShape(output_w, output_h, output_b);
}

References ARM_COMPUTE_ERROR_ON_MSG, compute_deep_convolution_shape(), arm_compute::test::validation::conv_info, arm_compute::DIV_CEIL(), arm_compute::test::validation::input_shape, DirectConvComputeKernelInfo::m0, arm_compute::NHWC, and arm_compute::test::validation::weights_shape.

Referenced by ClIndirectConv2dAddressPrecalculationKernel::configure(), and ClIndirectConv2d::validate().

compute_interleaved_shape()

TensorShape arm_compute::misc::shape_calculator::compute_interleaved_shape ( const ITensorInfo &  a, int  mult_interleave4x4_height = 1, bool  reinterpret_input_as_3d = false  )

inline

Calculate the interleaved shape of an input tensor.

Parameters

[in]	a	Input tensor info
[in]	mult_interleave4x4_height	(Optional) Interleave4x4 height
[in]	reinterpret_input_as_3d	(Optional) Set to true if the input need to be interpreted as 3d

Returns

the calculated shape

Definition at line 262 of file ShapeCalculator.h.

{
    // The interleaved output matrix will have the following shape: [ a_height * W, ceil(a_width / W) ] where W = 4 * mult_interleave4x4_height
    ARM_COMPUTE_ERROR_ON(mult_interleave4x4_height < 1);
    const int   interleave_width = 4 * mult_interleave4x4_height;
    TensorShape shape_interleaved_a{ a.tensor_shape() };
    shape_interleaved_a.set(0, a.dimension(0) * interleave_width);
    if(reinterpret_input_as_3d)
    {
        const int M      = a.dimension(1) * a.dimension(2);
        const int height = std::ceil(M / static_cast<float>(interleave_width));
        shape_interleaved_a.set(1, height);
 
        // When the data format is NHWC and the shapes are Nx1x1
        // the tensor shape num_dimensions is automatically set to 1 instead of 3.
        // To avoid failures by removing a dimension that doesn't exist
        // check if the number of dimensions is greater than 2.
        if(shape_interleaved_a.num_dimensions() > 2)
        {
            shape_interleaved_a.remove_dimension(2);
        }
    }
    else
    {
        shape_interleaved_a.set(1, std::ceil(a.dimension(1) / static_cast<float>(interleave_width)));
    }
 
    return shape_interleaved_a;
}

References ARM_COMPUTE_ERROR_ON, ITensorInfo::dimension(), M, TensorShape::set(), and ITensorInfo::tensor_shape().

Referenced by CpuGemmInterleave4x4Kernel::configure(), CpuGemmLowpMatrixMultiplyCore::configure(), CpuGemmInterleave4x4Kernel::validate(), and CpuGemm::validate().

compute_lhs_reshaped_shape()

TensorShape arm_compute::misc::shape_calculator::compute_lhs_reshaped_shape ( const ITensorInfo &  a, const GEMMLHSMatrixInfo &  lhs_info, bool  reinterpret_input_as_3d = false  )

inline

Calculate the Left Hand Side matrix reshaped shape.

Parameters

[in]	a	Input tensor info
[in]	lhs_info	Left Hand Side matrix information
[in]	reinterpret_input_as_3d	(Optional) Set to true if the input need to be interpreted as 3d

Returns

the calculated shape

Definition at line 182 of file ShapeCalculator.h.

{
    ARM_COMPUTE_ERROR_ON(lhs_info.m0 == 0);
    ARM_COMPUTE_ERROR_ON(lhs_info.k0 == 0);
    ARM_COMPUTE_ERROR_ON(lhs_info.v0 == 0);
 
    // Input width/height
    const unsigned int input_width  = a.dimension(0);
    const unsigned int input_height = reinterpret_input_as_3d ? a.dimension(1) * a.dimension(2) : a.dimension(1);
 
    // Number of horizontal/vertical blocks in the input tensor
    const unsigned int num_horiz_blocks = std::ceil(input_width / static_cast<float>(lhs_info.k0));
    const unsigned int num_vert_blocks  = std::ceil(input_height / static_cast<float>(lhs_info.m0));
 
    // Block size
    const unsigned int block_size = lhs_info.m0 * lhs_info.k0;
 
    // Output width/height
    const unsigned int output_width  = block_size * num_horiz_blocks * lhs_info.v0;
    const unsigned int output_height = std::ceil(num_vert_blocks / static_cast<float>(lhs_info.v0));
 
    TensorShape lhs_shape{ a.tensor_shape() };
    lhs_shape.set(0, output_width);
    lhs_shape.set(1, output_height);
 
    if((reinterpret_input_as_3d) && (lhs_shape.num_dimensions() > 2))
    {
        // When the data format is NHWC and the shapes are Nx1x1
        // the tensor shape num_dimensions is automatically set to 1 instead of 3.
        // To avoid failures by removing a dimension that doesn't exist
        // check if the number of dimensions is greater than 2.
        lhs_shape.remove_dimension(2);
    }
 
    return lhs_shape;
}

References ARM_COMPUTE_ERROR_ON, ITensorInfo::dimension(), input_height, input_width, arm_compute::test::validation::lhs_info, TensorShape::remove_dimension(), TensorShape::set(), and ITensorInfo::tensor_shape().

compute_matmul_shape()

TensorShape arm_compute::misc::shape_calculator::compute_matmul_shape ( const TensorShape &  input0, const TensorShape &  input1, const MatMulKernelInfo &  matmul_info  )

inline

Calculate the matrix multiplication output shape of two tensors.

Parameters

[in]	input0	First input tensor info
[in]	input1	Second input tensor info
[in]	matmul_info	Batch MatMul Kernel info to know which matrix is transposed

Returns

the calculated shape

Definition at line 1019 of file ShapeCalculator.h.

{
    TensorShape output_shape{ input0 };
 
    if(matmul_info.adj_lhs)
    {
        output_shape.set(1, input0[0]); // The vertical (M) dimension
    }
 
    if(matmul_info.adj_rhs)
    {
        output_shape.set(0, input1[1]); // The horizontal (N) dimension
    }
    else
    {
        output_shape.set(0, input1[0]); // The horizontal (N) dimension
    }
 
    return output_shape;
}

References MatMulKernelInfo::adj_lhs, MatMulKernelInfo::adj_rhs, and arm_compute::test::validation::output_shape.

Referenced by ClMatMulNativeKernel::configure(), ClMatMulLowpNativeKernel::configure(), ClMatMulNativeMMULKernel::configure(), ClMatMulNativeKernel::validate(), ClMatMulLowpNativeKernel::validate(), and ClMatMulNativeMMULKernel::validate().

compute_min_max_shape()

TensorShape arm_compute::misc::shape_calculator::compute_min_max_shape ( const ITensorInfo *  input )

inline

Calculate the min/max shape output shape of a tensor.

Parameters

[in]

input

Input tensor info

Returns

the calculated shape

Definition at line 786 of file ShapeCalculator.h.

{
    TensorShape output_shape{ input->tensor_shape() };
    output_shape.set(Window::DimX, 2);
    output_shape.remove_dimension(1);
    output_shape.remove_dimension(1);
 
    return output_shape;
}

References Window::DimX, arm_compute::test::validation::input, and arm_compute::test::validation::output_shape.

compute_mm_shape() [1/3]

TensorShape arm_compute::misc::shape_calculator::compute_mm_shape ( const ITensorInfo &  input0, const ITensorInfo &  input1, bool  is_interleaved_transposed, const GEMMReshapeInfo &  reshape_info  )

inline

Calculate the matrix multiplication output shape of two tensors.

Parameters

[in]	input0	First input tensor info
[in]	input1	Second input tensor info
[in]	is_interleaved_transposed	True if the input is interleaved transposed
[in]	reshape_info	GEMM reshape info

Returns

the calculated shape

Definition at line 907 of file ShapeCalculator.h.

{
    ARM_COMPUTE_ERROR_ON_MSG(input0.num_dimensions() > 4, "The number of dimensions for the matrix A must be <= 4");
    ARM_COMPUTE_ERROR_ON_MSG(is_interleaved_transposed && reshape_info.reinterpret_input_as_3d(), "The first input tensor cannot be reinterpreted as 3D if is_interleaved_transposed is true");
 
    const bool reinterpret_input_as_3d  = reshape_info.reinterpret_input_as_3d();
    const bool reinterpret_output_as_3d = reshape_info.depth_output_gemm3d() != 0;
    const int  depth_output_gemm3d      = reinterpret_output_as_3d ? reshape_info.depth_output_gemm3d() : 1;
    const int  m                        = reshape_info.reinterpret_input_as_3d() ? input0.dimension(1) * input0.dimension(2) : input0.dimension(1);
 
    // If the output of GEMM has to be reinterpreted as 3D, the number of input0 rows (M) is obtained collapsing the second and third
    // dimension of the output tensor
    const int dim0 = is_interleaved_transposed ? reshape_info.n() : input1.dimension(0);
    const int dim1 = is_interleaved_transposed ? reshape_info.m() / depth_output_gemm3d : m / depth_output_gemm3d;
    const int dim2 = reinterpret_input_as_3d ? input0.tensor_shape()[3] : input0.tensor_shape()[2];
    const int dim3 = reinterpret_input_as_3d ? 1 : input0.tensor_shape()[3];
 
    TensorShape output_shape{ input0.tensor_shape() };
 
    output_shape.set(0, dim0);
    output_shape.set(1, dim1);
    output_shape.set(2, reinterpret_output_as_3d ? depth_output_gemm3d : dim2);
    output_shape.set(3, reinterpret_output_as_3d ? dim2 : dim3);
    output_shape.set(4, reinterpret_output_as_3d ? dim3 : 1);
 
    return output_shape;
}

References ARM_COMPUTE_ERROR_ON_MSG, GEMMReshapeInfo::depth_output_gemm3d(), ITensorInfo::dimension(), arm_compute::test::validation::m, GEMMReshapeInfo::m(), GEMMReshapeInfo::n(), ITensorInfo::num_dimensions(), arm_compute::test::validation::output_shape, GEMMReshapeInfo::reinterpret_input_as_3d(), and ITensorInfo::tensor_shape().

Referenced by ClGemmMatrixMultiplyNativeKernel::configure(), ClGemmMatrixMultiplyReshapedOnlyRhsMMULKernel::configure(), ClGemmMatrixMultiplyReshapedOnlyRhsKernel::configure(), ClGemmMatrixMultiplyReshapedKernel::configure(), ClGemmLowpMatrixMultiplyCore::validate(), and CpuGemm::validate().

compute_mm_shape() [2/3]

TensorShape arm_compute::misc::shape_calculator::compute_mm_shape ( const ITensorInfo &  input0, const ITensorInfo &  input1, const GEMMKernelInfo &  gemm_info  )

inline

Calculate the matrix multiplication output shape of two tensors.

Parameters

[in]	input0	First input tensor info
[in]	input1	Second input tensor info
[in]	gemm_info	GEMM kernel info used to retrieve the original dimensions of the input matrices

Returns

the calculated shape

Definition at line 981 of file ShapeCalculator.h.

{
    ARM_COMPUTE_UNUSED(input1);
    ARM_COMPUTE_ERROR_ON_MSG(input0.num_dimensions() > 4, "The number of dimensions for the matrix A must be <= 4");
 
    const bool         reinterpret_input_as_3d  = gemm_info.reinterpret_input_as_3d;
    const bool         reinterpret_output_as_3d = gemm_info.depth_output_gemm3d != 0;
    const unsigned int depth_output_gemm3d      = reinterpret_output_as_3d ? gemm_info.depth_output_gemm3d : 1;
 
    TensorShape output_shape{ input0.tensor_shape() };
 
    if(!reinterpret_input_as_3d && !reinterpret_output_as_3d)
    {
        output_shape.set(0, gemm_info.n);
        output_shape.set(1, gemm_info.m);
    }
    else
    {
        // If the output of GEMM has to be reinterpreted as 3D, the number of input0 rows (M) is obtained collapsing the second and third
        // dimension of the output tensor
        const unsigned int batch_size = reinterpret_input_as_3d ? input0.tensor_shape()[3] : input0.tensor_shape()[2];
        output_shape.set(0, gemm_info.n);
        output_shape.set(1, gemm_info.m / depth_output_gemm3d);
        output_shape.set(2, reinterpret_output_as_3d ? depth_output_gemm3d : batch_size);
        output_shape.set(3, reinterpret_output_as_3d ? batch_size : 1);
    }
 
    return output_shape;
}

References ARM_COMPUTE_ERROR_ON_MSG, ARM_COMPUTE_UNUSED, arm_compute::test::validation::gemm_info, ITensorInfo::num_dimensions(), arm_compute::test::validation::output_shape, and ITensorInfo::tensor_shape().

compute_mm_shape() [3/3]

TensorShape arm_compute::misc::shape_calculator::compute_mm_shape ( const ITensorInfo &  input0, const ITensorInfo &  input1, const GEMMReshapeInfo &  gemm_info  )

inline

Calculate the matrix multiplication output shape of two tensors.

Parameters

[in]	input0	First input tensor info
[in]	input1	Second input tensor info
[in]	gemm_info	GEMM reshape info

Returns

the calculated shape

Definition at line 943 of file ShapeCalculator.h.

{
    ARM_COMPUTE_UNUSED(input1);
    ARM_COMPUTE_ERROR_ON_MSG(input0.num_dimensions() > 4, "The number of dimensions for the matrix A must be <= 4");
 
    const bool reinterpret_input_as_3d  = gemm_info.reinterpret_input_as_3d();
    const bool reinterpret_output_as_3d = gemm_info.depth_output_gemm3d() != 0;
    const int  depth_output_gemm3d      = reinterpret_output_as_3d ? gemm_info.depth_output_gemm3d() : 1;
 
    TensorShape output_shape{ input0.tensor_shape() };
 
    if(!reinterpret_input_as_3d && !reinterpret_output_as_3d)
    {
        output_shape.set(0, gemm_info.n());
        output_shape.set(1, gemm_info.m());
    }
    else
    {
        // If the output of GEMM has to be reinterpreted as 3D, the number of input0 rows (M) is obtained collapsing the second and third
        // dimension of the output tensor
        const int batch_size = reinterpret_input_as_3d ? input0.tensor_shape()[3] : input0.tensor_shape()[2];
        output_shape.set(0, gemm_info.n());
        output_shape.set(1, gemm_info.m() / depth_output_gemm3d);
        output_shape.set(2, reinterpret_output_as_3d ? depth_output_gemm3d : batch_size);
        output_shape.set(3, reinterpret_output_as_3d ? batch_size : 1);
    }
 
    return output_shape;
}

References ARM_COMPUTE_ERROR_ON_MSG, ARM_COMPUTE_UNUSED, arm_compute::test::validation::gemm_info, ITensorInfo::num_dimensions(), arm_compute::test::validation::output_shape, and ITensorInfo::tensor_shape().

compute_output_stage_shape()

TensorShape arm_compute::misc::shape_calculator::compute_output_stage_shape ( const ITensorInfo &  input, unsigned int  gemm_3d_depth = 1, bool  batch_size_on_z = false  )

inline

Calculate the matrix multiplication output shape of two tensors.

Parameters

[in]	input	Input tensor info
[in]	gemm_3d_depth	(Optional) GEMM 3d depth
[in]	batch_size_on_z	(Optional) True if batch size is on z axis

Returns

the calculated shape

Definition at line 1047 of file ShapeCalculator.h.

{
    ARM_COMPUTE_ERROR_ON(input.data_layout() != DataLayout::NHWC && gemm_3d_depth > 1);
 
    TensorShape output_shape = input.tensor_shape();
    if(gemm_3d_depth > 1)
    {
        if(batch_size_on_z)
        {
            output_shape.shift_right(1);
        }
        output_shape.set(0, input.tensor_shape().x());
        output_shape.set(1, input.tensor_shape().y() / gemm_3d_depth);
        output_shape.set(2, gemm_3d_depth);
    }
 
    return output_shape;
}

References ARM_COMPUTE_ERROR_ON, arm_compute::test::validation::input, arm_compute::NHWC, and arm_compute::test::validation::output_shape.

compute_padded_shape()

TensorShape arm_compute::misc::shape_calculator::compute_padded_shape ( const TensorShape &  input_shape, const PaddingList &  padding  )

inline

Calculate the padded shape of a tensor.

Parameters

[in]	input_shape	Input tensor shape
[in]	padding	Paddings list

Returns

the calculated shape

Definition at line 1276 of file ShapeCalculator.h.

{
    TensorShape padded_shape = input_shape;
    for(size_t dim = 0; dim < padding.size(); ++dim)
    {
        const auto    &padding_pair   = padding[dim];
        const uint32_t shape_on_index = (padded_shape.num_dimensions() <= dim) ? 1 : input_shape[dim];
        padded_shape.set(dim, padding_pair.first + shape_on_index + padding_pair.second);
    }
    return padded_shape;
}

References arm_compute::test::validation::input_shape, Dimensions< T >::num_dimensions(), and TensorShape::set().

Referenced by NEPadLayerKernel::configure(), CLPadLayerKernel::configure(), NEPadLayer::configure(), arm_compute::test::validation::reference::pad_layer(), and NEPadLayer::validate().

compute_permutation_output_shape()

TensorShape arm_compute::misc::shape_calculator::compute_permutation_output_shape ( const ITensorInfo &  input, const PermutationVector &  perm  )

inline

Calculate the permuted shape of an input given a permutation vector.

Parameters

[in]	input	Input tensor info
[in]	perm	Permutation vector

Returns

the calculated shape

Definition at line 110 of file ShapeCalculator.h.

{
    TensorShape output_shape = input.tensor_shape();
    permute(output_shape, perm);
    return output_shape;
}

References arm_compute::test::validation::input, arm_compute::test::validation::output_shape, and arm_compute::permute().

Referenced by CpuPermuteKernel::configure(), CPPPermuteKernel::configure(), ClSoftmax::validate(), and CpuSoftmaxGeneric< IS_LOG >::validate().

compute_pool3d_shape()

TensorShape arm_compute::misc::shape_calculator::compute_pool3d_shape ( const TensorShape &  src, Pooling3dLayerInfo  pool3d_info  )

inline

Calculate the output pool3d shape of a tensor.

Parameters

[in]	src	Input tensor info
[in]	pool3d_info	Pooling layer info

Returns

the calculated shape

Definition at line 1540 of file ShapeCalculator.h.

{
    TensorShape output_shape{ src };
 
    const auto data_layout      = DataLayout::NDHWC;
    const int  idx_width        = get_data_layout_dimension_index(data_layout, DataLayoutDimension::WIDTH);
    const int  idx_height       = get_data_layout_dimension_index(data_layout, DataLayoutDimension::HEIGHT);
    const int  idx_depth        = get_data_layout_dimension_index(data_layout, DataLayoutDimension::DEPTH);
    const int  pool_size_width  = pool3d_info.is_global_pooling ? src[idx_width] : pool3d_info.pool_size.width;
    const int  pool_size_height = pool3d_info.is_global_pooling ? src[idx_height] : pool3d_info.pool_size.height;
    const int  pool_size_depth  = pool3d_info.is_global_pooling ? src[idx_depth] : pool3d_info.pool_size.depth;
    int        output_width     = 0;
    int        output_height    = 0;
    int        output_depth     = 0;
 
    std::tie(output_width, output_height, output_depth) = scaled_3d_dimensions_signed(src[idx_width], src[idx_height], src[idx_depth], pool_size_width, pool_size_height,
                                                                                      pool_size_depth, pool3d_info);
 
    ARM_COMPUTE_ERROR_ON_MSG((output_width < 1 || output_height < 1 || output_depth < 1), "Calculated output dimension size is invalid");
 
    output_shape.set(idx_width, static_cast<size_t>(output_width));
    output_shape.set(idx_height, static_cast<size_t>(output_height));
    output_shape.set(idx_depth, static_cast<size_t>(output_depth));
 
    return output_shape;
}

References ARM_COMPUTE_ERROR_ON_MSG, arm_compute::test::validation::data_layout, Size3D::depth, arm_compute::DEPTH, arm_compute::get_data_layout_dimension_index(), Size3D::height, arm_compute::HEIGHT, arm_compute::test::validation::idx_height, arm_compute::test::validation::idx_width, Pooling3dLayerInfo::is_global_pooling, arm_compute::NDHWC, arm_compute::test::validation::output_shape, Pooling3dLayerInfo::pool_size, arm_compute::scaled_3d_dimensions_signed(), arm_compute::test::validation::src, Size3D::width, and arm_compute::WIDTH.

Referenced by ClPool3dKernel::configure(), CpuPool3dKernel::configure(), and arm_compute::test::validation::reference::pooling_3d_layer_internal().

compute_pool_shape()

TensorShape arm_compute::misc::shape_calculator::compute_pool_shape ( const ITensorInfo &  input, PoolingLayerInfo  pool_info  )

inline

Calculate the output pool shape of a tensor.

Parameters

[in]	input	Input tensor info
[in]	pool_info	Pooling layer info

Returns

the calculated shape

Definition at line 803 of file ShapeCalculator.h.

{
    int pooled_w = 0;
    int pooled_h = 0;
 
    TensorShape output_shape{ input.tensor_shape() };
 
    const bool is_global_pooling = pool_info.is_global_pooling;
    const int  idx_width         = get_data_layout_dimension_index(input.data_layout(), DataLayoutDimension::WIDTH);
    const int  idx_height        = get_data_layout_dimension_index(input.data_layout(), DataLayoutDimension::HEIGHT);
    const int  input_width       = input.tensor_shape()[idx_width];
    const int  input_height      = input.tensor_shape()[idx_height];
    const int  pool_size_x       = is_global_pooling ? output_shape[idx_width] : pool_info.pool_size.width;
    const int  pool_size_y       = is_global_pooling ? output_shape[idx_height] : pool_info.pool_size.height;
 
    std::tie(pooled_w, pooled_h) = scaled_dimensions_signed(input_width, input_height,
                                                            pool_size_x, pool_size_y,
                                                            pool_info.pad_stride_info);
 
    ARM_COMPUTE_ERROR_ON_MSG((pooled_w < 1 || pooled_h < 1), "Calculated output dimension size is invalid");
 
    output_shape.set(idx_width, static_cast<size_t>(pooled_w));
    output_shape.set(idx_height, static_cast<size_t>(pooled_h));
 
    return output_shape;
}

References ARM_COMPUTE_ERROR_ON_MSG, arm_compute::get_data_layout_dimension_index(), Size2D::height, arm_compute::HEIGHT, arm_compute::test::validation::idx_height, arm_compute::test::validation::idx_width, arm_compute::test::validation::input, input_height, input_width, PoolingLayerInfo::is_global_pooling, arm_compute::test::validation::output_shape, PoolingLayerInfo::pad_stride_info, PoolingLayerInfo::pool_size, arm_compute::scaled_dimensions_signed(), Size2D::width, and arm_compute::WIDTH.

Referenced by ClPool2dKernel::configure(), CpuPool2dAssemblyWrapperKernel::configure(), GpuPool2d::create_op(), GpuPool2d::is_supported_op(), arm_compute::test::validation::reference::pooling_layer_internal(), ClComponentPool2d::validate(), and GpuPool2d::validate_op().

compute_prior_box_shape()

TensorShape arm_compute::misc::shape_calculator::compute_prior_box_shape ( const ITensorInfo &  input, const PriorBoxLayerInfo &  info  )

inline

Calculate the prior box output shape of a tensor.

Parameters

[in]	input	Input tensor info
[in]	info	PriorBoxLayer info

Returns

the calculated shape

Definition at line 1255 of file ShapeCalculator.h.

{
    DataLayout   data_layout = input.data_layout();
    const size_t idx_w       = get_data_layout_dimension_index(data_layout, DataLayoutDimension::WIDTH);
    const size_t idx_h       = get_data_layout_dimension_index(data_layout, DataLayoutDimension::HEIGHT);
    const int    num_priors  = info.aspect_ratios().size() * info.min_sizes().size() + info.max_sizes().size();
 
    TensorShape output_shape{};
    output_shape.set(0, input.dimension(idx_w) * input.dimension(idx_h) * num_priors * 4);
    output_shape.set(1, 2);
 
    return output_shape;
}

References arm_compute::test::validation::data_layout, arm_compute::get_data_layout_dimension_index(), arm_compute::HEIGHT, arm_compute::test::validation::info, arm_compute::test::validation::input, arm_compute::test::validation::output_shape, and arm_compute::WIDTH.

compute_reduced_shape()

TensorShape arm_compute::misc::shape_calculator::compute_reduced_shape ( const TensorShape &  input, unsigned int  axis, bool  keep_dims = true  )

inline

Calculate the reduced shape of a tensor given an axis.

Parameters

[in]	input	Input tensor info
[in]	axis	Axis on which to perform reduction
[in]	keep_dims	(Optional) Whether to keep the dimension after reduction operation. Defaults to true.

Returns

the calculated shape

Definition at line 1313 of file ShapeCalculator.h.

{
    TensorShape output_shape{ input };
 
    if(!keep_dims)
    {
        output_shape.remove_dimension(axis);
    }
    else
    {
        output_shape.set(axis, 1);
    }
 
    return output_shape;
}

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

Referenced by NEReductionOperationKernel::configure(), CLReductionOperationKernel::configure(), NEReductionOperation::configure(), CLReductionOperation::configure(), CLArgMinMaxLayer::configure(), ReductionLayerNode::configure_output(), ArgMinMaxLayerNode::configure_output(), NEReductionOperation::validate(), CLArgMinMaxLayer::validate(), and CLReductionOperation::validate().

compute_reductionA_shape()

TensorShape arm_compute::misc::shape_calculator::compute_reductionA_shape ( const ITensorInfo &  b )

inline

Calculate the reductionA shape used in GEMMLowp.

Parameters

[in]

b

Input tensor info

Returns

the calculated shape

Definition at line 335 of file ShapeCalculator.h.

{
    TensorShape shape_vector_sum_col{ b.tensor_shape() };
    if(shape_vector_sum_col.num_dimensions() > 1)
    {
        shape_vector_sum_col.remove_dimension(1);
    }
 
    return shape_vector_sum_col;
}

References arm_compute::test::validation::b.

Referenced by ClGemmLowpMatrixMultiplyCore::configure(), CpuGemmLowpMatrixMultiplyCore::configure(), ClGemmLowpMatrixMultiplyCore::validate(), and CpuGemmLowpMatrixMultiplyCore::validate().

compute_reductionB_shape()

TensorShape arm_compute::misc::shape_calculator::compute_reductionB_shape ( const ITensorInfo &  a )

inline

Calculate the reductionB shape used in GEMMLowp.

Parameters

[in]

a

Input tensor info

Returns

the calculated shape

Definition at line 352 of file ShapeCalculator.h.

{
    TensorShape shape_vector_sum_row{ a.tensor_shape() };
    shape_vector_sum_row.set(Window::DimX, a.dimension(1));
    if(shape_vector_sum_row.num_dimensions() > 1)
    {
        shape_vector_sum_row.remove_dimension(1);
    }
 
    return shape_vector_sum_row;
}

References ITensorInfo::dimension(), Window::DimX, TensorShape::remove_dimension(), TensorShape::set(), and ITensorInfo::tensor_shape().

Referenced by ClGemmLowpMatrixMultiplyCore::configure(), CpuGemmLowpMatrixMultiplyCore::configure(), ClGemmLowpMatrixMultiplyCore::validate(), and CpuGemmLowpMatrixMultiplyCore::validate().

compute_reorg_output_shape()

TensorShape arm_compute::misc::shape_calculator::compute_reorg_output_shape ( const ITensorInfo &  input, int32_t  stride  )

inline

Calculate the output shape of the reorg layer given a stride.

Parameters

[in]	input	Input tensor info
[in]	stride	Stride

Returns

the calculated shape

Definition at line 124 of file ShapeCalculator.h.

{
    const size_t idx_width   = get_data_layout_dimension_index(input.data_layout(), DataLayoutDimension::WIDTH);
    const size_t idx_height  = get_data_layout_dimension_index(input.data_layout(), DataLayoutDimension::HEIGHT);
    const size_t idx_channel = get_data_layout_dimension_index(input.data_layout(), DataLayoutDimension::CHANNEL);
 
    ARM_COMPUTE_ERROR_ON(stride <= 0);
    ARM_COMPUTE_ERROR_ON_MSG((input.tensor_shape()[idx_width] % stride != 0), "The width of the input tensor must be a multiple of stride");
    ARM_COMPUTE_ERROR_ON_MSG((input.tensor_shape()[idx_height] % stride != 0), "The height of the input tensor must be a multiple of stride");
 
    TensorShape output_shape{ input.tensor_shape() };
 
    output_shape.set(idx_width, output_shape[idx_width] / stride);
    output_shape.set(idx_height, output_shape[idx_height] / stride);
    output_shape.set(idx_channel, output_shape[idx_channel] * stride * stride);
 
    return output_shape;
}

References ARM_COMPUTE_ERROR_ON, ARM_COMPUTE_ERROR_ON_MSG, arm_compute::CHANNEL, arm_compute::get_data_layout_dimension_index(), arm_compute::HEIGHT, arm_compute::test::validation::idx_height, arm_compute::test::validation::idx_width, arm_compute::test::validation::input, arm_compute::test::validation::output_shape, and arm_compute::WIDTH.

Referenced by NEReorgLayerKernel::configure(), CLReorgLayerKernel::configure(), and arm_compute::test::validation::reference::reorg_layer().

compute_rhs_reshaped_shape()

TensorShape arm_compute::misc::shape_calculator::compute_rhs_reshaped_shape ( const ITensorInfo &  a, const GEMMRHSMatrixInfo &  rhs_info  )

inline

Calculate the Right Hand Side matrix reshaped shape.

Parameters

[in]	a	Input tensor info
[in]	rhs_info	Right Hand Side matrix information

Returns

the calculated shape

Definition at line 226 of file ShapeCalculator.h.

{
    ARM_COMPUTE_ERROR_ON(rhs_info.n0 == 0);
    ARM_COMPUTE_ERROR_ON(rhs_info.k0 == 0);
    ARM_COMPUTE_ERROR_ON(rhs_info.h0 == 0);
 
    // Input width/height
    const unsigned int input_width  = a.dimension(0);
    const unsigned int input_height = a.dimension(1);
 
    // Number of horizontal/vertical blocks in the input tensor
    const unsigned int num_horiz_blocks = std::ceil(input_width / static_cast<float>(rhs_info.n0));
    const unsigned int num_vert_blocks  = std::ceil(input_height / static_cast<float>(rhs_info.k0));
 
    // Block size
    const unsigned int block_size = rhs_info.n0 * rhs_info.k0;
 
    // Output width/height
    const unsigned int output_width  = block_size * num_vert_blocks * rhs_info.h0;
    const unsigned int output_height = std::ceil(num_horiz_blocks / static_cast<float>(rhs_info.h0));
 
    TensorShape rhs_shape{ a.tensor_shape() };
    rhs_shape.set(0, output_width);
    rhs_shape.set(1, output_height);
 
    return rhs_shape;
}

References ARM_COMPUTE_ERROR_ON, ITensorInfo::dimension(), input_height, input_width, arm_compute::test::validation::rhs_info, TensorShape::set(), and ITensorInfo::tensor_shape().

Referenced by arm_compute::opencl::kernels::gemm::select_lhs_rhs_info(), and ClGemmLowpMatrixMultiplyCore::validate().

compute_rnn_shape()

TensorShape arm_compute::misc::shape_calculator::compute_rnn_shape ( const ITensorInfo *  input, const unsigned int  batch_size  )

inline

Calculate the RNN shape of a tensor.

Parameters

[in]	input	Input tensor info
[in]	batch_size	Batch size

Returns

the calculated shape

Definition at line 890 of file ShapeCalculator.h.

{
    TensorShape output_shape{ input->tensor_shape() };
    output_shape.set(1, batch_size);
 
    return output_shape;
}

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

Referenced by NERNNLayer::configure(), CLRNNLayer::configure(), NERNNLayer::validate(), and CLRNNLayer::validate().

compute_roi_align_shape()

TensorShape arm_compute::misc::shape_calculator::compute_roi_align_shape ( const ITensorInfo &  input, const ITensorInfo &  rois, ROIPoolingLayerInfo  pool_info  )

inline

Calculate the output roi align shape of a tensor.

Parameters

[in]	input	Input tensor info
[in]	rois	Rois tensor info
[in]	pool_info	Pooling layer info

Returns

the calculated shape

Definition at line 869 of file ShapeCalculator.h.

{
    TensorShape output_shape{ input.tensor_shape() };
 
    const unsigned int idx_width  = get_data_layout_dimension_index(input.data_layout(), DataLayoutDimension::WIDTH);
    const unsigned int idx_height = get_data_layout_dimension_index(input.data_layout(), DataLayoutDimension::HEIGHT);
 
    output_shape.set(idx_width, pool_info.pooled_width());
    output_shape.set(idx_height, pool_info.pooled_height());
    output_shape.set(3, rois.dimension(1));
 
    return output_shape;
}

References ITensorInfo::dimension(), arm_compute::get_data_layout_dimension_index(), arm_compute::HEIGHT, arm_compute::test::validation::idx_height, arm_compute::test::validation::idx_width, arm_compute::test::validation::input, arm_compute::test::validation::output_shape, ROIPoolingLayerInfo::pooled_height(), ROIPoolingLayerInfo::pooled_width(), and arm_compute::WIDTH.

Referenced by NEROIAlignLayerKernel::configure(), and CLROIAlignLayerKernel::configure().

compute_slice_shape()

TensorShape arm_compute::misc::shape_calculator::compute_slice_shape ( const TensorShape &  input_shape, const Coordinates &  starts, const Coordinates &  ends  )

inline

Calculate the slice output shape of a tensor.

Parameters

[in]	input_shape	Input tensor info
[in]	starts	The starts of the dimensions of the input tensor to be sliced
[in]	ends	The ends of the dimensions of the input tensor to be sliced

Returns

the calculated shape

Definition at line 1094 of file ShapeCalculator.h.

{
    using namespace arm_compute::helpers::tensor_transform;
 
    return compute_strided_slice_output_shape(input_shape,
                                              starts, ends, BiStrides(),
                                              0, construct_slice_end_mask(ends), 0);
}

References arm_compute::helpers::tensor_transform::compute_strided_slice_output_shape(), arm_compute::helpers::tensor_transform::construct_slice_end_mask(), and arm_compute::test::validation::input_shape.

Referenced by SliceLayerNode::compute_output_descriptor(), and arm_compute::test::validation::reference::slice().

compute_softmax_shape()

TensorShape arm_compute::misc::shape_calculator::compute_softmax_shape ( const ITensorInfo *  input, size_t  axis = 1  )

inline

Calculate the softmax output shape of a tensor.

Parameters

[in]	input	Input tensor info
[in]	axis	(Optional) Softmax axis

Returns

the calculated shape

Definition at line 581 of file ShapeCalculator.h.

{
    // The output shape will be a 2D version of the input. For instance:
    // - [x,y,z] and axis 1 will return [x, y*z]
    // - [x,y,z,w] and axis 2 will return [x*y, w*z]
    // - [x,y,z,w] and axis 3 will return [x*y*z, w]
    TensorShape shape2D = input->tensor_shape();
 
    if(axis < input->num_dimensions())
    {
        // Collapse from axis onward (this changes the shape)
        shape2D.collapse_from(axis);
 
        // Collapse the rest (collapse is inclusive)
        shape2D.collapse(shape2D.num_dimensions() - 1);
    }
    else
    {
        // Collapse everything
        shape2D.collapse(shape2D.num_dimensions());
    }
 
    if(axis == 0)
    {
        // If axis is zero the first dim should be one. Since
        // collapse is an inclusive operation we need to shift
        shape2D.shift_right(1);
    }
 
    return shape2D;
}

References TensorShape::collapse(), Dimensions< T >::collapse_from(), arm_compute::test::validation::input, Dimensions< T >::num_dimensions(), and TensorShape::shift_right().

compute_space_to_batch_shape()

TensorShape arm_compute::misc::shape_calculator::compute_space_to_batch_shape ( const ITensorInfo *  input, int  block_x, int  block_y, const Size2D &  padding_left, const Size2D &  padding_right  )

inline

Calculate the space to batch output shape of a tensor.

Parameters

[in]	input	Input tensor info
[in]	block_x	Block shape x value
[in]	block_y	Block shape y value
[in]	padding_left	Left padding values
[in]	padding_right	Right padding values

Returns

the calculated shape

Definition at line 1206 of file ShapeCalculator.h.

{
    TensorShape output_shape{ input->tensor_shape() };
 
    const DataLayout data_layout = input->data_layout();
    const int        idx_width   = get_data_layout_dimension_index(data_layout, DataLayoutDimension::WIDTH);
    const int        idx_height  = get_data_layout_dimension_index(data_layout, DataLayoutDimension::HEIGHT);
    const int        idx_batch   = get_data_layout_dimension_index(data_layout, DataLayoutDimension::BATCHES);
 
    ARM_COMPUTE_ERROR_ON((input->tensor_shape()[idx_width] + padding_left.x() + padding_right.x()) % block_x != 0);
    ARM_COMPUTE_ERROR_ON((input->tensor_shape()[idx_height] + padding_left.y() + padding_right.y()) % block_y != 0);
 
    output_shape.set(idx_width, (input->tensor_shape()[idx_width] + padding_left.x() + padding_right.x()) / block_x);
    output_shape.set(idx_height, (input->tensor_shape()[idx_height] + padding_left.y() + padding_right.y()) / block_y);
    output_shape.set(idx_batch, input->tensor_shape()[idx_batch] * block_x * block_y);
 
    return output_shape;
}

References ARM_COMPUTE_ERROR_ON, arm_compute::BATCHES, arm_compute::test::validation::data_layout, arm_compute::get_data_layout_dimension_index(), arm_compute::HEIGHT, arm_compute::test::validation::idx_height, arm_compute::test::validation::idx_width, arm_compute::test::validation::input, arm_compute::test::validation::output_shape, arm_compute::WIDTH, Size2D::x(), and Size2D::y().

Referenced by NESpaceToBatchLayerKernel::configure(), and CLSpaceToBatchLayerKernel::configure().

compute_space_to_depth_shape()

TensorShape arm_compute::misc::shape_calculator::compute_space_to_depth_shape ( const ITensorInfo *  input, int32_t  block_shape  )

inline

Calculate the space to batch output shape of a tensor.

Parameters

[in]	input	Input tensor info
[in]	block_shape	Block shape value

Returns

the calculated shape

Definition at line 1232 of file ShapeCalculator.h.

{
    TensorShape output_shape{ input->tensor_shape() };
 
    const DataLayout data_layout = input->data_layout();
    const int        idx_width   = get_data_layout_dimension_index(data_layout, DataLayoutDimension::WIDTH);
    const int        idx_height  = get_data_layout_dimension_index(data_layout, DataLayoutDimension::HEIGHT);
    const int        idx_depth   = get_data_layout_dimension_index(data_layout, DataLayoutDimension::CHANNEL);
 
    output_shape.set(idx_width, input->tensor_shape()[idx_width] / block_shape);
    output_shape.set(idx_height, input->tensor_shape()[idx_height] / block_shape);
    output_shape.set(idx_depth, input->tensor_shape()[idx_depth] * (block_shape * block_shape));
 
    return output_shape;
}

References arm_compute::CHANNEL, arm_compute::test::validation::data_layout, arm_compute::get_data_layout_dimension_index(), arm_compute::HEIGHT, arm_compute::test::validation::idx_height, arm_compute::test::validation::idx_width, arm_compute::test::validation::input, arm_compute::test::validation::output_shape, and arm_compute::WIDTH.

Referenced by NESpaceToDepthLayerKernel::configure(), and CLSpaceToDepthLayerKernel::configure().

compute_split_shape()

TensorShape arm_compute::misc::shape_calculator::compute_split_shape ( const ITensorInfo *  input, unsigned int  axis, unsigned int  num_splits  )

inline

Calculate the split output shape of a tensor.

Parameters

[in]	input	Input tensor info
[in]	axis	Axis on which to split the input
[in]	num_splits	Number of splits

Returns

the calculated shape

Definition at line 1171 of file ShapeCalculator.h.

{
    TensorShape empty_shape;
    empty_shape.set(0, 0);
 
    TensorShape out_shape{ input->tensor_shape() };
 
    // Return empty shape if axis is invalid
    if(axis > input->tensor_shape().num_dimensions())
    {
        return empty_shape;
    }
 
    size_t axis_size = out_shape[axis];
 
    // Return empty shape if num_split is not valid
    if(axis_size % num_splits)
    {
        return empty_shape;
    }
 
    out_shape[axis] = axis_size / num_splits;
    return out_shape;
}

References arm_compute::test::validation::input, and TensorShape::set().

Referenced by CPPSplit< CLSlice, ICLTensor >::configure(), and CPPSplit< CLSlice, ICLTensor >::validate().

compute_stack_shape()

TensorShape arm_compute::misc::shape_calculator::compute_stack_shape ( const ITensorInfo &  a, unsigned int  axis, unsigned int  num_tensors  )

inline

Calculate the stack output shape of a tensor.

Parameters

[in]	a	Input tensor info
[in]	axis	Axis on which to perform the stack operation
[in]	num_tensors	Number of tensors to stack

Returns

the calculated shape

Definition at line 1446 of file ShapeCalculator.h.

{
    ARM_COMPUTE_ERROR_ON(axis > a.num_dimensions());
    ARM_COMPUTE_ERROR_ON(a.num_dimensions() > 4);
 
    TensorShape shape_out{ a.tensor_shape() };
    shape_out.set(axis, num_tensors);
 
    unsigned int i_shift = 0;
 
    for(unsigned int i = 0; i < a.num_dimensions(); ++i)
    {
        if(i == axis)
        {
            i_shift++;
        }
 
        shape_out.set(i + i_shift, a.tensor_shape()[i]);
    }
    return shape_out;
}

References ARM_COMPUTE_ERROR_ON, ITensorInfo::num_dimensions(), TensorShape::set(), and ITensorInfo::tensor_shape().

Referenced by StackLayerNode::compute_output_descriptor().

compute_strided_slice_shape()

TensorShape arm_compute::misc::shape_calculator::compute_strided_slice_shape ( const ITensorInfo &  input, const Coordinates &  starts, const Coordinates &  ends, const Coordinates &  strides, int32_t  begin_mask, int32_t  end_mask, int32_t  shrink_axis_mask  )

inline

Calculate the strided slice output shape of a tensor.

Parameters

[in]	input	Input tensor info
[in]	starts	The starts of the dimensions of the input tensor to be sliced
[in]	ends	The ends of the dimensions of the input tensor to be sliced
[in]	strides	The strides of the dimensions of the input tensor to be sliced
[in]	begin_mask	If the ith bit of begin_mask is set, starts[i] is ignored and the fullest possible range in that dimension is used instead.
[in]	end_mask	If the ith bit of end_mask is set, ends[i] is ignored and the fullest possible range in that dimension is used instead.
[in]	shrink_axis_mask	If the ith bit of shrink_axis_mask is set, it implies that the ith specification shrinks the dimensionality by 1

Returns

the calculated shape

Definition at line 1078 of file ShapeCalculator.h.

{
    using namespace arm_compute::helpers::tensor_transform;
    return compute_strided_slice_output_shape(input.tensor_shape(), starts, ends, strides, begin_mask, end_mask, shrink_axis_mask);
}

References arm_compute::helpers::tensor_transform::compute_strided_slice_output_shape(), and arm_compute::test::validation::input.

Referenced by CLStridedSliceKernel::configure().

compute_tiled_shape()

TensorShape arm_compute::misc::shape_calculator::compute_tiled_shape ( const TensorShape &  input_shape, const Multiples &  multiples  )

inline

Calculate the tiled shape of a tensor.

Parameters

[in]	input_shape	Input tensor shape
[in]	multiples	Paddings list

Returns

the calculated shape

Definition at line 1295 of file ShapeCalculator.h.

{
    TensorShape tiled_shape = input_shape;
    for(size_t dim = 0; dim < multiples.size(); ++dim)
    {
        tiled_shape.set(dim, input_shape[dim] * multiples[dim]);
    }
    return tiled_shape;
}

References arm_compute::test::validation::input_shape, and TensorShape::set().

Referenced by NETileKernel::configure(), CLTileKernel::configure(), and arm_compute::test::validation::reference::tile().

compute_transpose1xW_shape()

TensorShape arm_compute::misc::shape_calculator::compute_transpose1xW_shape ( const ITensorInfo &  b )

inline

Calculate the transposed 1xW shape.

Parameters

[in]

b

Input tensor info

Returns

the calculated shape

Definition at line 298 of file ShapeCalculator.h.

{
    // The transpose1xW output matrix will have the following shape: [ b_height * 16, ceil(b_width / 16.0f) ]
    TensorShape shape_transposed1xW_b{ b.tensor_shape() };
    shape_transposed1xW_b.set(0, b.dimension(1) * 16);
    shape_transposed1xW_b.set(1, std::ceil(b.dimension(0) / 16.f));
 
    return shape_transposed1xW_b;
}

References arm_compute::test::validation::b.

Referenced by CpuGemmLowpMatrixMultiplyCore::configure().

compute_transpose1xW_with_element_size_shape()

TensorShape arm_compute::misc::shape_calculator::compute_transpose1xW_with_element_size_shape ( const ITensorInfo &  b, int  mult_transpose1xW_width = 1  )

inline

Calculate the transposed 1xW width element shape.

Parameters

[in]	b	Input tensor info
[in]	mult_transpose1xW_width	(Optional) Transpose1xW width

Returns

the calculated shape

Definition at line 315 of file ShapeCalculator.h.

{
    // Note: mult_transpose1xW_width expresses the number of chunks with size 1x(W) we want to store on the same row
    //       The transpose1xW output matrix will have the following shape:
    //       [ b_height * W, ceil(b_width / W) ] where W = (16 / element size of the tensor) * mult_transpose1xW_width
    ARM_COMPUTE_ERROR_ON(mult_transpose1xW_width < 1);
    TensorShape  shape_transposed1xW_b{ b.tensor_shape() };
    const size_t transpose_width = (16 / b.element_size()) * mult_transpose1xW_width;
    shape_transposed1xW_b.set(0, b.dimension(1) * transpose_width);
    shape_transposed1xW_b.set(1, static_cast<size_t>(std::ceil(b.dimension(0) / static_cast<float>(transpose_width))));
 
    return shape_transposed1xW_b;
}

References ARM_COMPUTE_ERROR_ON, and arm_compute::test::validation::b.

Referenced by CpuGemmTranspose1xWKernel::configure(), CpuGemmTranspose1xWKernel::validate(), and CpuGemm::validate().

compute_transposed_shape()

TensorShape arm_compute::misc::shape_calculator::compute_transposed_shape ( const ITensorInfo &  input )

inline

Calculate the transposed shape of a tensor.

Parameters

[in]

input

Input tensor info

Returns

the calculated shape

Definition at line 404 of file ShapeCalculator.h.

{
    TensorShape shape_transposed{ input.tensor_shape() };
 
    shape_transposed.set(0, input.dimension(1), false);
    shape_transposed.set(1, input.dimension(0), false);
 
    return shape_transposed;
}

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

Referenced by CpuTransposeKernel::configure(), ClTransposeKernel::configure(), NELSTMLayer::configure(), CLLSTMLayer::configure(), CpuTransposeKernel::validate(), ClTransposeKernel::validate(), CpuMatMul::validate(), CpuFullyConnected::validate(), ClFullyConnected::validate(), NELSTMLayer::validate(), and CLLSTMLayer::validate().

compute_unpool_shape()

TensorShape arm_compute::misc::shape_calculator::compute_unpool_shape ( const ITensorInfo &  input, PoolingLayerInfo  pool_info  )

inline

Calculate the output unpool shape of a tensor.

Parameters

[in]	input	Input tensor info
[in]	pool_info	Pooling layer info

Returns

the calculated shape

Definition at line 837 of file ShapeCalculator.h.

{
    const unsigned int idx_width   = get_data_layout_dimension_index(input.data_layout(), DataLayoutDimension::WIDTH);
    const unsigned int idx_height  = get_data_layout_dimension_index(input.data_layout(), DataLayoutDimension::HEIGHT);
    const TensorShape  input_shape = input.tensor_shape();
    ARM_COMPUTE_ERROR_ON(input_shape[idx_height] <= 1 || input_shape[idx_width] <= 1);
    const PadStrideInfo pad_stride_info = pool_info.pad_stride_info;
    const unsigned int  stride_x        = pad_stride_info.stride().first;
    const unsigned int  stride_y        = pad_stride_info.stride().second;
 
    const int pad_left   = pad_stride_info.pad_left();
    const int pad_top    = pad_stride_info.pad_top();
    const int pad_right  = pad_stride_info.pad_right();
    const int pad_bottom = pad_stride_info.pad_bottom();
 
    TensorShape        output_shape = input_shape;
    const unsigned int out_width    = (input_shape[idx_width] - 1) * stride_x - pad_left - pad_right + pool_info.pool_size.width;
    const unsigned int out_height   = (input_shape[idx_height] - 1) * stride_y - pad_top - pad_bottom + pool_info.pool_size.height;
 
    output_shape.set(idx_width, out_width);
    output_shape.set(idx_height, out_height);
    return output_shape;
}

References ARM_COMPUTE_ERROR_ON, arm_compute::get_data_layout_dimension_index(), Size2D::height, arm_compute::HEIGHT, arm_compute::test::validation::idx_height, arm_compute::test::validation::idx_width, arm_compute::test::validation::input, arm_compute::test::validation::input_shape, arm_compute::test::validation::output_shape, PadStrideInfo::pad_bottom(), PadStrideInfo::pad_left(), PadStrideInfo::pad_right(), PoolingLayerInfo::pad_stride_info, PadStrideInfo::pad_top(), PoolingLayerInfo::pool_size, PadStrideInfo::stride(), Size2D::width, and arm_compute::WIDTH.

Referenced by CpuMaxUnpoolingLayerKernel::configure(), and CLMaxUnpoolingLayerKernel::configure().

compute_upsample_shape()

TensorShape arm_compute::misc::shape_calculator::compute_upsample_shape ( const ITensorInfo &  input, const Size2D &  info  )

inline

Calculate the upsampled shape of a tensor.

Parameters

[in]	input	Input tensor info
[in]	info	Contains stride information (x and y)

Returns

the calculated shape

Definition at line 1336 of file ShapeCalculator.h.

{
    const DataLayout data_layout = input.data_layout();
    const int        idx_width   = get_data_layout_dimension_index(data_layout, DataLayoutDimension::WIDTH);
    const int        idx_height  = get_data_layout_dimension_index(data_layout, DataLayoutDimension::HEIGHT);
 
    TensorShape        scale_out_shape(input.tensor_shape());
    const unsigned int out_x = input.dimension(idx_width) * info.x();
    const unsigned int out_y = input.dimension(idx_height) * info.y();
    scale_out_shape.set(idx_width, out_x);
    scale_out_shape.set(idx_height, out_y);
 
    return scale_out_shape;
}

References arm_compute::test::validation::data_layout, arm_compute::get_data_layout_dimension_index(), arm_compute::HEIGHT, arm_compute::test::validation::idx_height, arm_compute::test::validation::idx_width, arm_compute::test::validation::info, arm_compute::test::validation::input, TensorShape::set(), and arm_compute::WIDTH.

compute_vector_to_tensor_output_shape()

TensorShape arm_compute::misc::shape_calculator::compute_vector_to_tensor_output_shape ( const TensorShape &  input, size_t  conv_w, size_t  conv_h, const DataLayout &  data_layout  )

inline

Calculate the output tensor shape of a vector input given the convolution dimensions.

Parameters

[in]	input	Input tensor shape
[in]	conv_w	Convolution width
[in]	conv_h	Convolution height
[in]	data_layout	Data layout

Returns

the calculated shape

Definition at line 89 of file ShapeCalculator.h.

{
    const size_t idx_w = get_data_layout_dimension_index(data_layout, DataLayoutDimension::WIDTH);
    const size_t idx_h = get_data_layout_dimension_index(data_layout, DataLayoutDimension::HEIGHT);
    const size_t idx_c = get_data_layout_dimension_index(data_layout, DataLayoutDimension::CHANNEL);
 
    TensorShape output_shape(input);
    output_shape.set(idx_w, conv_w);
    output_shape.set(idx_h, conv_h);
    output_shape.set(idx_c, input.x() / (conv_w * conv_h));
 
    return output_shape;
}

References arm_compute::CHANNEL, arm_compute::test::validation::data_layout, arm_compute::get_data_layout_dimension_index(), arm_compute::HEIGHT, arm_compute::test::validation::input, arm_compute::test::validation::output_shape, and arm_compute::WIDTH.

compute_weights_reshaped_shape()

TensorShape arm_compute::misc::shape_calculator::compute_weights_reshaped_shape ( const ITensorInfo &  weights, bool  has_bias = false, unsigned int  num_groups = 1  )

inline

Calculate the reshaped shape of the weights.

Parameters

[in]	weights	Weights tensor info
[in]	has_bias	(Optional) Set to true if there is bias
[in]	num_groups	(Optional) Number of groups

Returns

the calculated shape of the reshaped weights

Definition at line 151 of file ShapeCalculator.h.

{
    // Number of groups greater than one are only supported for NCHW data layout, and the number of weights must be a multiple of it.
    ARM_COMPUTE_ERROR_ON(num_groups == 0);
    ARM_COMPUTE_ERROR_ON(weights.data_layout() == DataLayout::NHWC && num_groups > 1);
    ARM_COMPUTE_ERROR_ON((weights.dimension(3) % num_groups) != 0);
 
    // Calculate output shape
    TensorShape weights_reshaped{ weights.tensor_shape() };
    weights_reshaped.set(3, weights_reshaped[3] / num_groups);
 
    weights_reshaped.collapse(3);
    const size_t tmp_dim = weights_reshaped[0];
    weights_reshaped.set(0, weights_reshaped[1]);
    weights_reshaped.set(1, tmp_dim + (has_bias ? 1 : 0));
    if(weights.num_dimensions() < 5)
    {
        weights_reshaped.set(2, num_groups);
    }
 
    return weights_reshaped;
}

References ARM_COMPUTE_ERROR_ON, TensorShape::collapse(), ITensorInfo::data_layout(), ITensorInfo::dimension(), arm_compute::test::validation::has_bias, arm_compute::NHWC, ITensorInfo::num_dimensions(), arm_compute::test::validation::num_groups, TensorShape::set(), and ITensorInfo::tensor_shape().

Referenced by ClWeightsReshapeKernel::configure(), ClGemmConv2d::validate(), and CpuGemmConv2d::validate().

compute_winograd_filter_transform_shape()

TensorShape arm_compute::misc::shape_calculator::compute_winograd_filter_transform_shape ( const ITensorInfo &  input, const WinogradInfo &  winograd_info  )

inline

Calculate the winograd filter transform shape.

Parameters

[in]	input	Input tensor info
[in]	winograd_info	Winograd information

Returns

the calculated shape

Definition at line 620 of file ShapeCalculator.h.

{
    TensorShape tensor_shape{ input.tensor_shape() };
 
    const Size2D kernel_size      = winograd_info.kernel_size;
    const Size2D output_tile_size = winograd_info.output_tile_size;
    const Size2D input_tile_size  = Size2D(output_tile_size.width + kernel_size.width - 1, output_tile_size.height + kernel_size.height - 1);
 
    tensor_shape.remove_dimension(get_data_layout_dimension_index(input.data_layout(), DataLayoutDimension::WIDTH));
    tensor_shape.set(Window::DimX, input.dimension(3));
    tensor_shape.set(Window::DimY, input.dimension(get_data_layout_dimension_index(input.data_layout(), DataLayoutDimension::CHANNEL)));
    tensor_shape.set(Window::DimZ, input_tile_size.area());
 
    return tensor_shape;
}

References Size2D::area(), arm_compute::CHANNEL, Window::DimX, Window::DimY, Window::DimZ, arm_compute::get_data_layout_dimension_index(), Size2D::height, arm_compute::test::validation::input, WinogradInfo::kernel_size, WinogradInfo::output_tile_size, Size2D::width, and arm_compute::WIDTH.

Referenced by ClWinogradFilterTransformKernel::configure().

compute_winograd_input_transform_shape()

TensorShape arm_compute::misc::shape_calculator::compute_winograd_input_transform_shape ( const ITensorInfo &  input, const WinogradInfo &  winograd_info  )

inline

Calculate the winograd input transform shape.

Parameters

[in]	input	Input tensor info
[in]	winograd_info	Winograd information

Returns

the calculated shape

Definition at line 643 of file ShapeCalculator.h.

{
    const PadStrideInfo conv_info        = winograd_info.convolution_info;
    const Size2D        kernel_size      = winograd_info.kernel_size;
    const Size2D        output_tile_size = winograd_info.output_tile_size;
    const Size2D        input_tile_size  = Size2D(output_tile_size.width + kernel_size.width - 1, output_tile_size.height + kernel_size.height - 1);
 
    const size_t idx_w = get_data_layout_dimension_index(input.data_layout(), DataLayoutDimension::WIDTH);
    const size_t idx_h = get_data_layout_dimension_index(input.data_layout(), DataLayoutDimension::HEIGHT);
    const size_t idx_c = get_data_layout_dimension_index(input.data_layout(), DataLayoutDimension::CHANNEL);
 
    // Compute the number of output tiles along the x and y direction of size "output_tile_size"
    const Size2D num_tiles = compute_winograd_convolution_tiles(Size2D(input.tensor_shape()[idx_w], input.tensor_shape()[idx_h]),
                                                                kernel_size,
                                                                output_tile_size,
                                                                conv_info);
 
    const unsigned int width  = input.tensor_shape()[idx_c];
    const unsigned int height = num_tiles.area();
    const unsigned int depth  = input_tile_size.area();
 
    TensorShape output_shape{ input.tensor_shape() };
    output_shape.set(0, width);
    output_shape.set(1, height);
    output_shape.set(2, depth);
 
    return output_shape;
}

References Size2D::area(), arm_compute::CHANNEL, arm_compute::compute_winograd_convolution_tiles(), arm_compute::test::validation::conv_info, WinogradInfo::convolution_info, arm_compute::get_data_layout_dimension_index(), Size2D::height, arm_compute::HEIGHT, arm_compute::test::validation::input, WinogradInfo::kernel_size, arm_compute::test::validation::output_shape, WinogradInfo::output_tile_size, Size2D::width, and arm_compute::WIDTH.

Referenced by ClWinogradInputTransformKernel::configure().

compute_winograd_output_transform_shape()

TensorShape arm_compute::misc::shape_calculator::compute_winograd_output_transform_shape ( const ITensorInfo &  input, const WinogradInfo &  winograd_info  )

inline

Calculate the winograd output transform shape.

Parameters

[in]	input	Input tensor info
[in]	winograd_info	Winograd information

Returns

the calculated shape

Definition at line 679 of file ShapeCalculator.h.

{
    const PadStrideInfo conv_info        = winograd_info.convolution_info;
    const Size2D        kernel_size      = winograd_info.kernel_size;
    const Size2D        input_dimensions = winograd_info.input_dimensions;
    const DataLayout    data_layout      = winograd_info.output_data_layout;
 
    // Compute output shape
    unsigned int output_width  = 0;
    unsigned int output_height = 0;
    std::tie(output_width, output_height) = scaled_dimensions(input_dimensions.width, input_dimensions.height,
                                                              kernel_size.width, kernel_size.height, conv_info);
 
    TensorShape tensor_shape{ input.tensor_shape() };
 
    // Output dimension
    const unsigned int out_w = output_width;
    const unsigned int out_h = output_height;
    const unsigned int out_c = input.dimension(0);
 
    tensor_shape.set(get_data_layout_dimension_index(data_layout, DataLayoutDimension::WIDTH), out_w);
    tensor_shape.set(get_data_layout_dimension_index(data_layout, DataLayoutDimension::HEIGHT), out_h);
    tensor_shape.set(get_data_layout_dimension_index(data_layout, DataLayoutDimension::CHANNEL), out_c);
 
    return tensor_shape;
}

References arm_compute::CHANNEL, arm_compute::test::validation::conv_info, WinogradInfo::convolution_info, arm_compute::test::validation::data_layout, arm_compute::get_data_layout_dimension_index(), Size2D::height, arm_compute::HEIGHT, arm_compute::test::validation::input, WinogradInfo::input_dimensions, WinogradInfo::kernel_size, WinogradInfo::output_data_layout, arm_compute::scaled_dimensions(), Size2D::width, and arm_compute::WIDTH.

Referenced by ClWinogradOutputTransformKernel::configure().

extract_shape() [1/5]

TensorShape arm_compute::misc::shape_calculator::extract_shape ( const ITensorInfo *  data )

inline

Definition at line 1367 of file ShapeCalculator.h.

{
    return data->tensor_shape();
}

References ITensorInfo::tensor_shape().

extract_shape() [2/5]

TensorShape arm_compute::misc::shape_calculator::extract_shape ( const TensorShape *  data )

inline

Definition at line 1372 of file ShapeCalculator.h.

{
    return *data;
}

extract_shape() [3/5]

TensorShape arm_compute::misc::shape_calculator::extract_shape ( ITensorInfo *  data )

inline

Definition at line 1363 of file ShapeCalculator.h.

{
    return data->tensor_shape();
}

References ITensorInfo::tensor_shape().

extract_shape() [4/5]

TensorShape arm_compute::misc::shape_calculator::extract_shape ( T *  data )

inline

Get the tensor shape.

Parameters

[in]

data

Input data

Returns

the extracted tensor shape

Definition at line 1358 of file ShapeCalculator.h.

{
    return data->info()->tensor_shape();
}

Referenced by calculate_concatenate_shape().

extract_shape() [5/5]

TensorShape arm_compute::misc::shape_calculator::extract_shape ( TensorShape *  data )

inline

Definition at line 1377 of file ShapeCalculator.h.

{
    return *data;
}