arm_compute::test::validation::reference Namespace Reference

Enumerations
enum	ArithmeticOperation { ADD, SUB }
	Arithmetic operation types. More...
enum	FFTDirection { Forward, Inverse }
enum	WinogradTransformType { INPUT, FILTER, OUTPUT }
	Winograd transform type. More...

Functions
template<typename T >
SimpleTensor< T >	absolute_difference (const SimpleTensor< T > &src1, const SimpleTensor< T > &src2, DataType dst_data_type)
template SimpleTensor< uint8_t >	absolute_difference (const SimpleTensor< uint8_t > &src1, const SimpleTensor< uint8_t > &src2, DataType dst_data_type)
template SimpleTensor< int16_t >	absolute_difference (const SimpleTensor< int16_t > &src1, const SimpleTensor< int16_t > &src2, DataType dst_data_type)
template SimpleTensor< int8_t >	absolute_difference (const SimpleTensor< int8_t > &src1, const SimpleTensor< int8_t > &src2, DataType dst_data_type)
template<typename T1 , typename T2 >
SimpleTensor< T2 >	accumulate (const SimpleTensor< T1 > &src, DataType output_data_type)
template<typename T1 , typename T2 >
SimpleTensor< T2 >	accumulate_weighted (const SimpleTensor< T1 > &src, float alpha, DataType output_data_type)
template<typename T1 , typename T2 >
SimpleTensor< T2 >	accumulate_squared (const SimpleTensor< T1 > &src, uint32_t shift, DataType output_data_type)
template SimpleTensor< int16_t >	accumulate (const SimpleTensor< uint8_t > &src, DataType output_data_type)
template SimpleTensor< uint8_t >	accumulate_weighted (const SimpleTensor< uint8_t > &src, float alpha, DataType output_data_type)
template SimpleTensor< int16_t >	accumulate_squared (const SimpleTensor< uint8_t > &src, uint32_t shift, DataType output_data_type)
template<typename T >
SimpleTensor< T >	activation_layer (const SimpleTensor< T > &src, ActivationLayerInfo info, const QuantizationInfo &oq_info)
template<>
SimpleTensor< uint8_t >	activation_layer< uint8_t > (const SimpleTensor< uint8_t > &src, ActivationLayerInfo info, const QuantizationInfo &oq_info)
template<>
SimpleTensor< int8_t >	activation_layer< int8_t > (const SimpleTensor< int8_t > &src, ActivationLayerInfo info, const QuantizationInfo &oq_info)
template<>
SimpleTensor< int16_t >	activation_layer< int16_t > (const SimpleTensor< int16_t > &src, ActivationLayerInfo info, const QuantizationInfo &oq_info)
template SimpleTensor< int32_t >	activation_layer (const SimpleTensor< int32_t > &src, ActivationLayerInfo info, const QuantizationInfo &oq_info)
template SimpleTensor< float >	activation_layer (const SimpleTensor< float > &src, ActivationLayerInfo info, const QuantizationInfo &oq_info)
template SimpleTensor< half >	activation_layer (const SimpleTensor< half > &src, ActivationLayerInfo info, const QuantizationInfo &oq_info)
template<typename T >
T	activate_float (T x, T a, T b, ActivationLayerInfo::ActivationFunction activation)
template<typename T >
SimpleTensor< T >	arithmetic_division (const SimpleTensor< T > &src1, const SimpleTensor< T > &src2, DataType data_type)
template SimpleTensor< half >	arithmetic_division (const SimpleTensor< half > &src1, const SimpleTensor< half > &src2, DataType data_type)
template SimpleTensor< float >	arithmetic_division (const SimpleTensor< float > &src1, const SimpleTensor< float > &src2, DataType data_type)
template<typename T >
SimpleTensor< T >	arithmetic_operation (ArithmeticOperation op, const SimpleTensor< T > &src1, const SimpleTensor< T > &src2, SimpleTensor< T > &dst, ConvertPolicy convert_policy)
template<>
SimpleTensor< uint8_t >	arithmetic_operation (ArithmeticOperation op, const SimpleTensor< uint8_t > &src1, const SimpleTensor< uint8_t > &src2, SimpleTensor< uint8_t > &dst, ConvertPolicy convert_policy)
template<>
SimpleTensor< int8_t >	arithmetic_operation (ArithmeticOperation op, const SimpleTensor< int8_t > &src1, const SimpleTensor< int8_t > &src2, SimpleTensor< int8_t > &dst, ConvertPolicy convert_policy)
template<>
SimpleTensor< int16_t >	arithmetic_operation (ArithmeticOperation op, const SimpleTensor< int16_t > &src1, const SimpleTensor< int16_t > &src2, SimpleTensor< int16_t > &dst, ConvertPolicy convert_policy)
template SimpleTensor< int32_t >	arithmetic_operation (ArithmeticOperation op, const SimpleTensor< int32_t > &src1, const SimpleTensor< int32_t > &src2, SimpleTensor< int32_t > &dst, ConvertPolicy convert_policy)
template SimpleTensor< half >	arithmetic_operation (ArithmeticOperation op, const SimpleTensor< half > &src1, const SimpleTensor< half > &src2, SimpleTensor< half > &dst, ConvertPolicy convert_policy)
template SimpleTensor< float >	arithmetic_operation (ArithmeticOperation op, const SimpleTensor< float > &src1, const SimpleTensor< float > &src2, SimpleTensor< float > &dst, ConvertPolicy convert_policy)
template<typename T >
SimpleTensor< T >	arithmetic_operation (ArithmeticOperation op, const SimpleTensor< T > &src1, const SimpleTensor< T > &src2, DataType dst_data_type, ConvertPolicy convert_policy)
template SimpleTensor< int32_t >	arithmetic_operation (ArithmeticOperation op, const SimpleTensor< int32_t > &src1, const SimpleTensor< int32_t > &src2, DataType dst_data_type, ConvertPolicy convert_policy)
template SimpleTensor< int16_t >	arithmetic_operation (ArithmeticOperation op, const SimpleTensor< int16_t > &src1, const SimpleTensor< int16_t > &src2, DataType dst_data_type, ConvertPolicy convert_policy)
template SimpleTensor< int8_t >	arithmetic_operation (ArithmeticOperation op, const SimpleTensor< int8_t > &src1, const SimpleTensor< int8_t > &src2, DataType dst_data_type, ConvertPolicy convert_policy)
template SimpleTensor< half >	arithmetic_operation (ArithmeticOperation op, const SimpleTensor< half > &src1, const SimpleTensor< half > &src2, DataType dst_data_type, ConvertPolicy convert_policy)
template SimpleTensor< float >	arithmetic_operation (ArithmeticOperation op, const SimpleTensor< float > &src1, const SimpleTensor< float > &src2, DataType dst_data_type, ConvertPolicy convert_policy)
template<typename T , typename std::enable_if< is_floating_point< T >::value, int >::type * >
SimpleTensor< T >	batch_normalization_layer (const SimpleTensor< T > &src, const SimpleTensor< T > &mean, const SimpleTensor< T > &var, const SimpleTensor< T > &beta, const SimpleTensor< T > &gamma, float epsilon, ActivationLayerInfo act_info)
template SimpleTensor< float >	batch_normalization_layer (const SimpleTensor< float > &src, const SimpleTensor< float > &mean, const SimpleTensor< float > &var, const SimpleTensor< float > &beta, const SimpleTensor< float > &gamma, float epsilon, ActivationLayerInfo act_info)
template SimpleTensor< half >	batch_normalization_layer (const SimpleTensor< half > &src, const SimpleTensor< half > &mean, const SimpleTensor< half > &var, const SimpleTensor< half > &beta, const SimpleTensor< half > &gamma, float epsilon, ActivationLayerInfo act_info)
template<typename T >
SimpleTensor< T >	batch_to_space (const SimpleTensor< T > &src, const std::vector< int32_t > &block_shape, const CropInfo &crop_info, const TensorShape &dst_shape)
template SimpleTensor< float >	batch_to_space (const SimpleTensor< float > &src, const std::vector< int32_t > &block_shape, const CropInfo &crop_info, const TensorShape &dst_shape)
template SimpleTensor< half >	batch_to_space (const SimpleTensor< half > &src, const std::vector< int32_t > &block_shape, const CropInfo &crop_info, const TensorShape &dst_shape)
template<typename T >
SimpleTensor< T >	bitwise_and (const SimpleTensor< T > &src1, const SimpleTensor< T > &src2)
template SimpleTensor< uint8_t >	bitwise_and (const SimpleTensor< uint8_t > &src1, const SimpleTensor< uint8_t > &src2)
template<typename T >
SimpleTensor< T >	bitwise_not (const SimpleTensor< T > &src)
template SimpleTensor< uint8_t >	bitwise_not (const SimpleTensor< uint8_t > &src)
template<typename T >
SimpleTensor< T >	bitwise_or (const SimpleTensor< T > &src1, const SimpleTensor< T > &src2)
template SimpleTensor< uint8_t >	bitwise_or (const SimpleTensor< uint8_t > &src1, const SimpleTensor< uint8_t > &src2)
template<typename T >
SimpleTensor< T >	bitwise_xor (const SimpleTensor< T > &src1, const SimpleTensor< T > &src2)
template SimpleTensor< uint8_t >	bitwise_xor (const SimpleTensor< uint8_t > &src1, const SimpleTensor< uint8_t > &src2)
template<typename T , typename TDeltas >
SimpleTensor< T >	bounding_box_transform (const SimpleTensor< T > &boxes, const SimpleTensor< TDeltas > &deltas, const BoundingBoxTransformInfo &info)
template SimpleTensor< float >	bounding_box_transform (const SimpleTensor< float > &boxes, const SimpleTensor< float > &deltas, const BoundingBoxTransformInfo &info)
template SimpleTensor< half >	bounding_box_transform (const SimpleTensor< half > &boxes, const SimpleTensor< half > &deltas, const BoundingBoxTransformInfo &info)
template<>
SimpleTensor< uint16_t >	bounding_box_transform (const SimpleTensor< uint16_t > &boxes, const SimpleTensor< uint8_t > &deltas, const BoundingBoxTransformInfo &info)
template<typename T >
SimpleTensor< T >	channel_shuffle (const SimpleTensor< T > &src, int num_groups)
template SimpleTensor< uint8_t >	channel_shuffle (const SimpleTensor< uint8_t > &src, int num_groups)
template SimpleTensor< uint16_t >	channel_shuffle (const SimpleTensor< uint16_t > &src, int num_groups)
template SimpleTensor< uint32_t >	channel_shuffle (const SimpleTensor< uint32_t > &src, int num_groups)
template SimpleTensor< half >	channel_shuffle (const SimpleTensor< half > &src, int num_groups)
template SimpleTensor< float >	channel_shuffle (const SimpleTensor< float > &src, int num_groups)
template<typename T >
SimpleTensor< T >	col2im (const SimpleTensor< T > &src, const TensorShape &dst_shape, unsigned int num_groups)
template SimpleTensor< float >	col2im (const SimpleTensor< float > &src, const TensorShape &dst_shape, unsigned int num_groups)
template SimpleTensor< half >	col2im (const SimpleTensor< half > &src, const TensorShape &dst_shape, unsigned int num_groups)
template SimpleTensor< uint8_t >	col2im (const SimpleTensor< uint8_t > &src, const TensorShape &dst_shape, unsigned int num_groups)
template<typename T >
SimpleTensor< uint8_t >	compare (ComparisonOperation op, const SimpleTensor< T > &src1, const SimpleTensor< T > &src2)
template<>
SimpleTensor< uint8_t >	compare (ComparisonOperation op, const SimpleTensor< uint8_t > &src1, const SimpleTensor< uint8_t > &src2)
template<>
SimpleTensor< uint8_t >	compare (ComparisonOperation op, const SimpleTensor< int8_t > &src1, const SimpleTensor< int8_t > &src2)
template SimpleTensor< uint8_t >	compare (ComparisonOperation op, const SimpleTensor< half > &src1, const SimpleTensor< half > &src2)
template SimpleTensor< uint8_t >	compare (ComparisonOperation op, const SimpleTensor< float > &src1, const SimpleTensor< float > &src2)
template<typename T >
SimpleTensor< T >	compute_all_anchors (const SimpleTensor< T > &anchors, const ComputeAnchorsInfo &info)
template SimpleTensor< float >	compute_all_anchors (const SimpleTensor< float > &anchors, const ComputeAnchorsInfo &info)
template SimpleTensor< half >	compute_all_anchors (const SimpleTensor< half > &anchors, const ComputeAnchorsInfo &info)
template<>
SimpleTensor< int16_t >	compute_all_anchors (const SimpleTensor< int16_t > &anchors, const ComputeAnchorsInfo &info)
template<typename T >
SimpleTensor< T >	concatenate_layer (std::vector< SimpleTensor< T >> &srcs, SimpleTensor< T > &dst, unsigned int axis)
template SimpleTensor< float >	concatenate_layer (std::vector< SimpleTensor< float >> &srcs, SimpleTensor< float > &dst, unsigned int axis)
template SimpleTensor< half >	concatenate_layer (std::vector< SimpleTensor< half >> &srcs, SimpleTensor< half > &dst, unsigned int axis)
template SimpleTensor< uint8_t >	concatenate_layer (std::vector< SimpleTensor< uint8_t >> &srcs, SimpleTensor< uint8_t > &dst, unsigned int axis)
template SimpleTensor< int8_t >	concatenate_layer (std::vector< SimpleTensor< int8_t >> &srcs, SimpleTensor< int8_t > &dst, unsigned int axis)
template<typename T , typename TB >
SimpleTensor< T >	conv3d (const SimpleTensor< T > &src, const SimpleTensor< T > &weights, const SimpleTensor< TB > &bias, SimpleTensor< T > &dst, const Conv3dInfo &conv3d_info)
template SimpleTensor< float >	conv3d (const SimpleTensor< float > &src, const SimpleTensor< float > &weights, const SimpleTensor< float > &bias, SimpleTensor< float > &dst, const Conv3dInfo &conv3d_info)
template SimpleTensor< half >	conv3d (const SimpleTensor< half > &src, const SimpleTensor< half > &weights, const SimpleTensor< half > &bias, SimpleTensor< half > &dst, const Conv3dInfo &conv3d_info)
template SimpleTensor< uint8_t >	conv3d (const SimpleTensor< uint8_t > &src, const SimpleTensor< uint8_t > &weights, const SimpleTensor< int32_t > &bias, SimpleTensor< uint8_t > &dst, const Conv3dInfo &conv3d_info)
template SimpleTensor< int8_t >	conv3d (const SimpleTensor< int8_t > &src, const SimpleTensor< int8_t > &weights, const SimpleTensor< int32_t > &bias, SimpleTensor< int8_t > &dst, const Conv3dInfo &conv3d_info)
template<typename T >
SimpleTensor< T >	convert_fully_connected_weights (const SimpleTensor< T > &src, const TensorShape &original_input_shape, const DataLayout training_data_layout)
template SimpleTensor< uint8_t >	convert_fully_connected_weights (const SimpleTensor< uint8_t > &src, const TensorShape &original_input_shape, const DataLayout training_data_layout)
template SimpleTensor< half >	convert_fully_connected_weights (const SimpleTensor< half > &src, const TensorShape &original_input_shape, const DataLayout training_data_layout)
template SimpleTensor< float >	convert_fully_connected_weights (const SimpleTensor< float > &src, const TensorShape &original_input_shape, const DataLayout training_data_layout)
template<typename T , typename TW , typename TB >
SimpleTensor< T >	convolution_layer_nchw (const SimpleTensor< T > &src, const SimpleTensor< TW > &weights, const SimpleTensor< TB > &bias, SimpleTensor< T > &dst, const PadStrideInfo &info, const Size2D &dilation, unsigned int num_groups)
template<typename T , typename TW , typename TB >
SimpleTensor< T >	convolution_layer (const SimpleTensor< T > &src, const SimpleTensor< TW > &weights, const SimpleTensor< TB > &bias, const TensorShape &output_shape, const PadStrideInfo &info, const Size2D &dilation, unsigned int num_groups, QuantizationInfo out_quant_info)
template SimpleTensor< float >	convolution_layer (const SimpleTensor< float > &src, const SimpleTensor< float > &weights, const SimpleTensor< float > &bias, const TensorShape &output_shape, const PadStrideInfo &info, const Size2D &dilation, unsigned int num_groups, QuantizationInfo out_quant_info)
template SimpleTensor< half >	convolution_layer (const SimpleTensor< half > &src, const SimpleTensor< half > &weights, const SimpleTensor< half > &bias, const TensorShape &output_shape, const PadStrideInfo &info, const Size2D &dilation, unsigned int num_groups, QuantizationInfo out_quant_info)
template SimpleTensor< uint8_t >	convolution_layer (const SimpleTensor< uint8_t > &src, const SimpleTensor< uint8_t > &weights, const SimpleTensor< int32_t > &bias, const TensorShape &output_shape, const PadStrideInfo &info, const Size2D &dilation, unsigned int num_groups, QuantizationInfo out_quant_info)
template SimpleTensor< uint8_t >	convolution_layer (const SimpleTensor< uint8_t > &src, const SimpleTensor< int8_t > &weights, const SimpleTensor< int32_t > &bias, const TensorShape &output_shape, const PadStrideInfo &info, const Size2D &dilation, unsigned int num_groups, QuantizationInfo out_quant_info)
template SimpleTensor< int8_t >	convolution_layer (const SimpleTensor< int8_t > &src, const SimpleTensor< int8_t > &weights, const SimpleTensor< int32_t > &bias, const TensorShape &output_shape, const PadStrideInfo &info, const Size2D &dilation, unsigned int num_groups, QuantizationInfo out_quant_info)
template<typename T >
SimpleTensor< T >	copy (const SimpleTensor< T > &src, const TensorShape &output_shape)
template SimpleTensor< uint8_t >	copy (const SimpleTensor< uint8_t > &src, const TensorShape &output_shape)
template SimpleTensor< int8_t >	copy (const SimpleTensor< int8_t > &src, const TensorShape &output_shape)
template SimpleTensor< uint16_t >	copy (const SimpleTensor< uint16_t > &src, const TensorShape &output_shape)
template SimpleTensor< int16_t >	copy (const SimpleTensor< int16_t > &src, const TensorShape &output_shape)
template SimpleTensor< uint32_t >	copy (const SimpleTensor< uint32_t > &src, const TensorShape &output_shape)
template SimpleTensor< int32_t >	copy (const SimpleTensor< int32_t > &src, const TensorShape &output_shape)
template SimpleTensor< half >	copy (const SimpleTensor< half > &src, const TensorShape &output_shape)
template SimpleTensor< float >	copy (const SimpleTensor< float > &src, const TensorShape &output_shape)
template<typename T >
SimpleTensor< float >	crop_and_resize (const SimpleTensor< T > &src, const SimpleTensor< float > &boxes, SimpleTensor< int32_t > box_ind, Coordinates2D crop_size, InterpolationPolicy method, float extrapolation_value)
template SimpleTensor< float >	crop_and_resize (const SimpleTensor< float > &src, const SimpleTensor< float > &boxes, SimpleTensor< int32_t > box_ind, Coordinates2D crop_size, InterpolationPolicy method, float extrapolation_value)
template SimpleTensor< float >	crop_and_resize (const SimpleTensor< uint16_t > &src, const SimpleTensor< float > &boxes, SimpleTensor< int32_t > box_ind, Coordinates2D crop_size, InterpolationPolicy method, float extrapolation_value)
template SimpleTensor< float >	crop_and_resize (const SimpleTensor< uint32_t > &src, const SimpleTensor< float > &boxes, SimpleTensor< int32_t > box_ind, Coordinates2D crop_size, InterpolationPolicy method, float extrapolation_value)
template SimpleTensor< float >	crop_and_resize (const SimpleTensor< int16_t > &src, const SimpleTensor< float > &boxes, SimpleTensor< int32_t > box_ind, Coordinates2D crop_size, InterpolationPolicy method, float extrapolation_value)
template SimpleTensor< float >	crop_and_resize (const SimpleTensor< int32_t > &src, const SimpleTensor< float > &boxes, SimpleTensor< int32_t > box_ind, Coordinates2D crop_size, InterpolationPolicy method, float extrapolation_value)
template SimpleTensor< float >	crop_and_resize (const SimpleTensor< half > &src, const SimpleTensor< float > &boxes, SimpleTensor< int32_t > box_ind, Coordinates2D crop_size, InterpolationPolicy method, float extrapolation_value)
template SimpleTensor< float >	crop_and_resize (const SimpleTensor< uint8_t > &src, const SimpleTensor< float > &boxes, SimpleTensor< int32_t > box_ind, Coordinates2D crop_size, InterpolationPolicy method, float extrapolation_value)
template<typename T , typename TW , typename TB >
SimpleTensor< T >	deconvolution_layer (const SimpleTensor< T > &src, const SimpleTensor< TW > &weights, const SimpleTensor< TB > &bias, const TensorShape &output_shape, const PadStrideInfo &info, QuantizationInfo out_qinfo=QuantizationInfo())
	Deconvolution reference implementation. More...
template SimpleTensor< uint8_t >	deconvolution_layer (const SimpleTensor< uint8_t > &src, const SimpleTensor< uint8_t > &weights, const SimpleTensor< int32_t > &bias, const TensorShape &output_shape, const PadStrideInfo &info, QuantizationInfo out_quant_info)
template SimpleTensor< uint8_t >	deconvolution_layer (const SimpleTensor< uint8_t > &src, const SimpleTensor< int8_t > &weights, const SimpleTensor< int32_t > &bias, const TensorShape &output_shape, const PadStrideInfo &info, QuantizationInfo out_quant_info)
template SimpleTensor< int8_t >	deconvolution_layer (const SimpleTensor< int8_t > &src, const SimpleTensor< int8_t > &weights, const SimpleTensor< int32_t > &bias, const TensorShape &output_shape, const PadStrideInfo &info, QuantizationInfo out_quant_info)
template SimpleTensor< float >	deconvolution_layer (const SimpleTensor< float > &src, const SimpleTensor< float > &weights, const SimpleTensor< float > &bias, const TensorShape &output_shape, const PadStrideInfo &info, QuantizationInfo out_quant_info)
template SimpleTensor< half >	deconvolution_layer (const SimpleTensor< half > &src, const SimpleTensor< half > &weights, const SimpleTensor< half > &bias, const TensorShape &output_shape, const PadStrideInfo &info, QuantizationInfo out_quant_info)
template<typename T >
SimpleTensor< T >	depthconcatenate_layer (const std::vector< SimpleTensor< T >> &srcs, SimpleTensor< T > &dst)
template SimpleTensor< uint8_t >	depthconcatenate_layer (const std::vector< SimpleTensor< uint8_t >> &srcs, SimpleTensor< uint8_t > &dst)
template SimpleTensor< float >	depthconcatenate_layer (const std::vector< SimpleTensor< float >> &srcs, SimpleTensor< float > &dst)
template SimpleTensor< half >	depthconcatenate_layer (const std::vector< SimpleTensor< half >> &srcs, SimpleTensor< half > &dst)
template<typename T1 , typename T2 , typename std::enable_if< std::is_integral< T1 >::value &&!std::is_same< T1, T2 >::value, int >::type >
SimpleTensor< T2 >	depth_convert (const SimpleTensor< T1 > &src, DataType dt_out, ConvertPolicy policy, uint32_t shift)
template SimpleTensor< int8_t >	depth_convert (const SimpleTensor< uint8_t > &src, DataType dt_out, ConvertPolicy policy, uint32_t shift)
template SimpleTensor< uint8_t >	depth_convert (const SimpleTensor< int8_t > &src, DataType dt_out, ConvertPolicy policy, uint32_t shift)
template SimpleTensor< uint8_t >	depth_convert (const SimpleTensor< uint16_t > &src, DataType dt_out, ConvertPolicy policy, uint32_t shift)
template SimpleTensor< uint8_t >	depth_convert (const SimpleTensor< int16_t > &src, DataType dt_out, ConvertPolicy policy, uint32_t shift)
template SimpleTensor< uint8_t >	depth_convert (const SimpleTensor< uint32_t > &src, DataType dt_out, ConvertPolicy policy, uint32_t shift)
template SimpleTensor< uint8_t >	depth_convert (const SimpleTensor< int32_t > &src, DataType dt_out, ConvertPolicy policy, uint32_t shift)
template SimpleTensor< float >	depth_convert (const SimpleTensor< bfloat16 > &src, DataType dt_out, ConvertPolicy policy, uint32_t shift)
template SimpleTensor< uint8_t >	depth_convert (const SimpleTensor< half > &src, DataType dt_out, ConvertPolicy policy, uint32_t shift)
template SimpleTensor< uint8_t >	depth_convert (const SimpleTensor< float > &src, DataType dt_out, ConvertPolicy policy, uint32_t shift)
template SimpleTensor< uint8_t >	depth_convert (const SimpleTensor< int64_t > &src, DataType dt_out, ConvertPolicy policy, uint32_t shift)
template SimpleTensor< uint8_t >	depth_convert (const SimpleTensor< uint64_t > &src, DataType dt_out, ConvertPolicy policy, uint32_t shift)
template<typename T >
SimpleTensor< T >	depth_to_space (const SimpleTensor< T > &src, const TensorShape &dst_shape, int32_t block_shape)
template SimpleTensor< float >	depth_to_space (const SimpleTensor< float > &src, const TensorShape &dst_shape, int32_t block_shape)
template SimpleTensor< half >	depth_to_space (const SimpleTensor< half > &src, const TensorShape &dst_shape, int32_t block_shape)
template<>
SimpleTensor< float >	depthwise_convolution (const SimpleTensor< float > &src, const SimpleTensor< float > &weights, const SimpleTensor< float > &biases, const TensorShape &dst_shape, const PadStrideInfo &conv_info, unsigned int depth_multiplier, const Size2D &dilation, const QuantizationInfo &out_quant_info)
template<>
SimpleTensor< half >	depthwise_convolution (const SimpleTensor< half > &src, const SimpleTensor< half > &weights, const SimpleTensor< half > &biases, const TensorShape &dst_shape, const PadStrideInfo &conv_info, unsigned int depth_multiplier, const Size2D &dilation, const QuantizationInfo &out_quant_info)
template<>
SimpleTensor< uint8_t >	depthwise_convolution (const SimpleTensor< uint8_t > &src, const SimpleTensor< uint8_t > &weights, const SimpleTensor< int32_t > &biases, const TensorShape &dst_shape, const PadStrideInfo &conv_info, unsigned int depth_multiplier, const Size2D &dilation, const QuantizationInfo &out_quant_info)
template<>
SimpleTensor< uint8_t >	depthwise_convolution (const SimpleTensor< uint8_t > &src, const SimpleTensor< int8_t > &weights, const SimpleTensor< int32_t > &biases, const TensorShape &dst_shape, const PadStrideInfo &conv_info, unsigned int depth_multiplier, const Size2D &dilation, const QuantizationInfo &out_quant_info)
template<>
SimpleTensor< int8_t >	depthwise_convolution (const SimpleTensor< int8_t > &src, const SimpleTensor< int8_t > &weights, const SimpleTensor< int32_t > &biases, const TensorShape &dst_shape, const PadStrideInfo &conv_info, unsigned int depth_multiplier, const Size2D &dilation, const QuantizationInfo &out_quant_info)
template<typename T , typename TW , typename TB >
SimpleTensor< T >	depthwise_convolution (const SimpleTensor< T > &src, const SimpleTensor< TW > &weights, const SimpleTensor< TB > &biases, const TensorShape &dst_shape, const PadStrideInfo &conv_info, unsigned int depth_multiplier, const Size2D &dilation=Size2D(1U, 1U), const QuantizationInfo &out_quant_info=QuantizationInfo(0.0f, 0))
template<typename T >
SimpleTensor< T >	depthwise_separable_convolution_layer (const SimpleTensor< T > &src, const SimpleTensor< T > &depthwise_weights, const SimpleTensor< T > &depthwise_biases, const TensorShape &depthwise_out_shape, const SimpleTensor< T > &pointwise_weights, const SimpleTensor< T > &pointwise_biases, const TensorShape &dst_shape, const PadStrideInfo &depthwise_conv_info, const PadStrideInfo &pointwise_conv_info)
template<typename TOut , typename TIn >
SimpleTensor< TOut >	dequantization_layer (const SimpleTensor< TIn > &src)
template SimpleTensor< half >	dequantization_layer (const SimpleTensor< uint8_t > &src)
template SimpleTensor< half >	dequantization_layer (const SimpleTensor< int8_t > &src)
template SimpleTensor< half >	dequantization_layer (const SimpleTensor< int16_t > &src)
template<typename T >
SimpleTensor< T >	rdft_1d (const SimpleTensor< T > &src)
	Performs an one dimensional DFT on a real input. More...
template<typename T >
SimpleTensor< T >	ridft_1d (const SimpleTensor< T > &src, bool is_odd=false)
	Performs an one dimensional inverse DFT on a real input. More...
template<typename T >
SimpleTensor< T >	dft_1d (const SimpleTensor< T > &src, FFTDirection direction)
	Performs an one dimensional DFT on a complex input. More...
template<typename T >
SimpleTensor< T >	rdft_2d (const SimpleTensor< T > &src)
	Performs a two dimensional DFT on a real input. More...
template<typename T >
SimpleTensor< T >	ridft_2d (const SimpleTensor< T > &src, bool is_odd=false)
	Performs a two dimensional inverse DFT on a real input. More...
template<typename T >
SimpleTensor< T >	dft_2d (const SimpleTensor< T > &src, FFTDirection direction)
	Performs a two dimensional DFT on a complex input. More...
template<typename T >
SimpleTensor< T >	conv2d_dft (const SimpleTensor< T > &src, const SimpleTensor< T > &w, const PadStrideInfo &conv_info)
	Performs and DFT based convolution on a real input. More...
template SimpleTensor< float >	rdft_1d (const SimpleTensor< float > &src)
template SimpleTensor< float >	ridft_1d (const SimpleTensor< float > &src, bool is_odd)
template SimpleTensor< float >	dft_1d (const SimpleTensor< float > &src, FFTDirection direction)
template SimpleTensor< float >	rdft_2d (const SimpleTensor< float > &src)
template SimpleTensor< float >	ridft_2d (const SimpleTensor< float > &src, bool is_odd)
template SimpleTensor< float >	dft_2d (const SimpleTensor< float > &src, FFTDirection direction)
template SimpleTensor< float >	conv2d_dft (const SimpleTensor< float > &src, const SimpleTensor< float > &w, const PadStrideInfo &conv_info)
template SimpleTensor< half >	rdft_1d (const SimpleTensor< half > &src)
template SimpleTensor< half >	ridft_1d (const SimpleTensor< half > &src, bool is_odd)
template SimpleTensor< half >	dft_1d (const SimpleTensor< half > &src, FFTDirection direction)
template SimpleTensor< half >	rdft_2d (const SimpleTensor< half > &src)
template SimpleTensor< half >	ridft_2d (const SimpleTensor< half > &src, bool is_odd)
template SimpleTensor< half >	dft_2d (const SimpleTensor< half > &src, FFTDirection direction)
template SimpleTensor< half >	conv2d_dft (const SimpleTensor< half > &src, const SimpleTensor< half > &w, const PadStrideInfo &conv_info)
template<typename T >
SimpleTensor< T >	elementwise_unary (const SimpleTensor< T > &src, SimpleTensor< T > &dst, ElementWiseUnary op)
template<>
SimpleTensor< int8_t >	elementwise_unary (const SimpleTensor< int8_t > &src, SimpleTensor< int8_t > &dst, ElementWiseUnary op)
template<>
SimpleTensor< uint8_t >	elementwise_unary (const SimpleTensor< uint8_t > &src, SimpleTensor< uint8_t > &dst, ElementWiseUnary op)
template SimpleTensor< float >	elementwise_unary (const SimpleTensor< float > &src, SimpleTensor< float > &dst, ElementWiseUnary op)
template SimpleTensor< half >	elementwise_unary (const SimpleTensor< half > &src, SimpleTensor< half > &dst, ElementWiseUnary op)
template SimpleTensor< int32_t >	elementwise_unary (const SimpleTensor< int32_t > &src, SimpleTensor< int32_t > &dst, ElementWiseUnary op)
template<typename T >
SimpleTensor< T >	erode (const SimpleTensor< T > &src, BorderMode border_mode, T constant_border_value)
template SimpleTensor< uint8_t >	erode (const SimpleTensor< uint8_t > &src, BorderMode border_mode, uint8_t constant_border_value)
template<typename T >
SimpleTensor< T >	flatten_layer (const SimpleTensor< T > &src, const TensorShape &shape_flatten)
template SimpleTensor< float >	flatten_layer (const SimpleTensor< float > &src, const TensorShape &shape_flatten)
template SimpleTensor< half >	flatten_layer (const SimpleTensor< half > &src, const TensorShape &shape_flatten)
template<typename T >
SimpleTensor< T >	floor_layer (const SimpleTensor< T > &src)
template SimpleTensor< half >	floor_layer (const SimpleTensor< half > &src)
template SimpleTensor< float >	floor_layer (const SimpleTensor< float > &src)
template<typename T , typename TB >
SimpleTensor< T >	fully_connected_layer (const SimpleTensor< T > &src, const SimpleTensor< T > &weights, const SimpleTensor< TB > &bias, const TensorShape &dst_shape, QuantizationInfo out_quant_info)
template SimpleTensor< float >	fully_connected_layer (const SimpleTensor< float > &src, const SimpleTensor< float > &weights, const SimpleTensor< float > &bias, const TensorShape &dst_shape, QuantizationInfo out_quant_info)
template SimpleTensor< half >	fully_connected_layer (const SimpleTensor< half > &src, const SimpleTensor< half > &weights, const SimpleTensor< half > &bias, const TensorShape &dst_shape, QuantizationInfo out_quant_info)
template SimpleTensor< uint8_t >	fully_connected_layer (const SimpleTensor< uint8_t > &src, const SimpleTensor< uint8_t > &weights, const SimpleTensor< int32_t > &bias, const TensorShape &dst_shape, QuantizationInfo out_quant_info)
template SimpleTensor< int8_t >	fully_connected_layer (const SimpleTensor< int8_t > &src, const SimpleTensor< int8_t > &weights, const SimpleTensor< int32_t > &bias, const TensorShape &dst_shape, QuantizationInfo out_quant_info)
template<typename T >
void	fuse_batch_normalization_dwc_layer (const SimpleTensor< T > &w, const SimpleTensor< T > &mean, const SimpleTensor< T > &var, SimpleTensor< T > &w_fused, SimpleTensor< T > &b_fused, const SimpleTensor< T > &b, const SimpleTensor< T > &beta, const SimpleTensor< T > &gamma, float epsilon)
template<typename T >
void	fuse_batch_normalization_conv_layer (const SimpleTensor< T > &w, const SimpleTensor< T > &mean, const SimpleTensor< T > &var, SimpleTensor< T > &w_fused, SimpleTensor< T > &b_fused, const SimpleTensor< T > &b, const SimpleTensor< T > &beta, const SimpleTensor< T > &gamma, float epsilon)
template void	fuse_batch_normalization_dwc_layer (const SimpleTensor< float > &w, const SimpleTensor< float > &mean, const SimpleTensor< float > &var, SimpleTensor< float > &w_fused, SimpleTensor< float > &b_fused, const SimpleTensor< float > &b, const SimpleTensor< float > &beta, const SimpleTensor< float > &gamma, float epsilon)
template void	fuse_batch_normalization_dwc_layer (const SimpleTensor< half > &w, const SimpleTensor< half > &mean, const SimpleTensor< half > &var, SimpleTensor< half > &w_fused, SimpleTensor< half > &b_fused, const SimpleTensor< half > &b, const SimpleTensor< half > &beta, const SimpleTensor< half > &gamma, float epsilon)
template void	fuse_batch_normalization_conv_layer (const SimpleTensor< float > &w, const SimpleTensor< float > &mean, const SimpleTensor< float > &var, SimpleTensor< float > &w_fused, SimpleTensor< float > &b_fused, const SimpleTensor< float > &b, const SimpleTensor< float > &beta, const SimpleTensor< float > &gamma, float epsilon)
template void	fuse_batch_normalization_conv_layer (const SimpleTensor< half > &w, const SimpleTensor< half > &mean, const SimpleTensor< half > &var, SimpleTensor< half > &w_fused, SimpleTensor< half > &b_fused, const SimpleTensor< half > &b, const SimpleTensor< half > &beta, const SimpleTensor< half > &gamma, float epsilon)
template<typename T >
SimpleTensor< T >	gather (const SimpleTensor< T > &src, const SimpleTensor< uint32_t > &indices, uint32_t actual_axis)
template SimpleTensor< float >	gather (const SimpleTensor< float > &src, const SimpleTensor< uint32_t > &indices, uint32_t actual_axis)
template SimpleTensor< half >	gather (const SimpleTensor< half > &src, const SimpleTensor< uint32_t > &indices, uint32_t actual_axis)
template SimpleTensor< uint16_t >	gather (const SimpleTensor< uint16_t > &src, const SimpleTensor< uint32_t > &indices, uint32_t actual_axis)
template SimpleTensor< uint8_t >	gather (const SimpleTensor< uint8_t > &src, const SimpleTensor< uint32_t > &indices, uint32_t actual_axis)
template<typename T , typename std::enable_if< is_floating_point< T >::value, int >::type >
SimpleTensor< T >	gemm (const SimpleTensor< T > &a, const SimpleTensor< T > &b, const SimpleTensor< T > &c, float alpha, float beta)
template<typename T , typename std::enable_if< is_floating_point< T >::value, int >::type >
SimpleTensor< T >	gemm_mixed_precision (const SimpleTensor< T > &a, const SimpleTensor< T > &b, const SimpleTensor< T > &c, float alpha, float beta)
template SimpleTensor< float >	gemm (const SimpleTensor< float > &a, const SimpleTensor< float > &b, const SimpleTensor< float > &c, float alpha, float beta)
template SimpleTensor< half >	gemm (const SimpleTensor< half > &a, const SimpleTensor< half > &b, const SimpleTensor< half > &c, float alpha, float beta)
template SimpleTensor< half >	gemm_mixed_precision (const SimpleTensor< half > &a, const SimpleTensor< half > &b, const SimpleTensor< half > &c, float alpha, float beta)
template<typename T >
SimpleTensor< T >	gemm_interleave_4x4 (const SimpleTensor< T > &in, SimpleTensor< T > &out)
template<typename T >
T	safe_read (const SimpleTensor< T > &t, int y, int x)
template<typename T >
SimpleTensor< T >	gemm_interleave_blocked (const SimpleTensor< T > &in, SimpleTensor< T > &out, int int_by, int block, bool transposed)
template SimpleTensor< uint8_t >	gemm_interleave_blocked (const SimpleTensor< uint8_t > &in, SimpleTensor< uint8_t > &out, int int_by, int block, bool transposed)
template<typename T_out , typename T_in , typename T_in_1 >
SimpleTensor< T_out >	gemmlowp_matrix_multiply_core (const SimpleTensor< T_in > &a, const SimpleTensor< T_in_1 > &b, TensorShape shape_c, int32_t a_offset, int32_t b_offset)
template<typename T1 , typename T2 , typename T3 >
SimpleTensor< T1 >	gemmlowp (const SimpleTensor< T2 > &a, const SimpleTensor< T3 > &b, TensorShape shape_c)
template<typename TIn , typename TOut >
SimpleTensor< TOut >	gemmlowp_quantize_down_scale (const SimpleTensor< TIn > &in, int32_t result_offset, std::vector< int32_t > result_mult_int, std::vector< int32_t > result_shift, int32_t min, int32_t max)
template<typename TIn , typename TOut >
SimpleTensor< TOut >	gemmlowp_quantize_down_scale (const SimpleTensor< TIn > &in, const SimpleTensor< TIn > &bias, int32_t result_offset, std::vector< int32_t > result_mult_int, std::vector< int32_t > result_shift, int32_t min, int32_t max)
template<typename TIn , typename TOut >
SimpleTensor< TOut >	gemmlowp_quantize_down_scale_by_fixedpoint (const SimpleTensor< TIn > &in, std::vector< int32_t > result_fixedpoint_multiplier, std::vector< int32_t > result_shift, int32_t result_offset_after_shift, int32_t min, int32_t max)
template<typename TIn , typename TOut >
SimpleTensor< TOut >	gemmlowp_quantize_down_scale_by_fixedpoint (const SimpleTensor< TIn > &in, const SimpleTensor< TIn > &bias, std::vector< int32_t > result_fixedpoint_multiplier, std::vector< int32_t > result_shift, int32_t result_offset_after_shift, int32_t min, int32_t max)
template<typename TIn , typename TOut >
SimpleTensor< TOut >	gemmlowp_quantize_down_scale_by_float (const SimpleTensor< TIn > &in, const SimpleTensor< TIn > &bias, std::vector< float_t > result_real_multiplier, int32_t result_offset, int32_t min, int32_t max)
template<typename TIn , typename TOut >
SimpleTensor< TOut >	gemmlowp_quantize_down_scale_by_float (const SimpleTensor< TIn > &in, std::vector< float_t > result_real_multiplier, int32_t result_offset, int32_t min, int32_t max)
template SimpleTensor< uint8_t >	gemmlowp_quantize_down_scale_by_float (const SimpleTensor< int32_t > &a, const SimpleTensor< int32_t > &b, std::vector< float_t > result_real_multiplier, int32_t result_offset, int32_t min, int32_t max)
template SimpleTensor< uint8_t >	gemmlowp_quantize_down_scale_by_float (const SimpleTensor< int32_t > &a, std::vector< float_t > result_real_multiplier, int32_t result_offset, int32_t min, int32_t max)
template SimpleTensor< uint8_t >	gemmlowp_quantize_down_scale_by_fixedpoint (const SimpleTensor< int32_t > &a, std::vector< int32_t > result_fixedpoint_multiplier, std::vector< int32_t > result_shift, int32_t result_offset_after_shift, int32_t min, int32_t max)
template SimpleTensor< uint8_t >	gemmlowp_quantize_down_scale_by_fixedpoint (const SimpleTensor< int32_t > &a, const SimpleTensor< int32_t > &b, std::vector< int32_t > result_fixedpoint_multiplier, std::vector< int32_t > result_shift, int32_t result_offset_after_shift, int32_t min, int32_t max)
template SimpleTensor< uint8_t >	gemmlowp_quantize_down_scale (const SimpleTensor< int32_t > &a, int32_t result_offset, std::vector< int32_t > result_mult_int, std::vector< int32_t > result_shift, int32_t min, int32_t max)
template SimpleTensor< uint8_t >	gemmlowp_quantize_down_scale (const SimpleTensor< int32_t > &a, const SimpleTensor< int32_t > &b, int32_t result_offset, std::vector< int32_t > result_mult_int, std::vector< int32_t > result_shift, int32_t min, int32_t max)
template SimpleTensor< int32_t >	gemmlowp_matrix_multiply_core (const SimpleTensor< int8_t > &a, const SimpleTensor< int8_t > &b, TensorShape shape_c, int32_t a_offset, int32_t b_offset)
template SimpleTensor< int32_t >	gemmlowp_matrix_multiply_core (const SimpleTensor< uint8_t > &a, const SimpleTensor< uint8_t > &b, TensorShape shape_c, int32_t a_offset, int32_t b_offset)
template SimpleTensor< int32_t >	gemmlowp< int32_t, int8_t, int8_t > (const SimpleTensor< int8_t > &a, const SimpleTensor< int8_t > &b, TensorShape shape_c)
template SimpleTensor< int32_t >	gemmlowp< int32_t, uint8_t, uint8_t > (const SimpleTensor< uint8_t > &a, const SimpleTensor< uint8_t > &b, TensorShape shape_c)
template SimpleTensor< int32_t >	gemmlowp< int32_t, uint8_t, int8_t > (const SimpleTensor< uint8_t > &a, const SimpleTensor< int8_t > &b, TensorShape shape_c)
template<typename T1 , typename T2 , typename T3 >
SimpleTensor< T1 >	gemmlowp_matrix_multiply_core (const SimpleTensor< T2 > &a, const SimpleTensor< T3 > &b, TensorShape shape_c, int32_t a_offset, int32_t b_offset)
template<typename TIn , typename TOut >
SimpleTensor< uint8_t >	gemmlowp_quantize_down_scale (const SimpleTensor< TIn > &in, int32_t result_offset, std::vector< int32_t > result_mult_int, std::vector< int32_t > result_shift)
template<typename T >
SimpleTensor< T >	gemm_reshape_lhs_matrix (const SimpleTensor< T > &in, const TensorShape &output_shape, const GEMMLHSMatrixInfo &lhs_info)
template SimpleTensor< int >	gemm_reshape_lhs_matrix (const SimpleTensor< int > &in, const TensorShape &output_shape, const GEMMLHSMatrixInfo &lhs_info)
template SimpleTensor< short >	gemm_reshape_lhs_matrix (const SimpleTensor< short > &in, const TensorShape &output_shape, const GEMMLHSMatrixInfo &lhs_info)
template SimpleTensor< char >	gemm_reshape_lhs_matrix (const SimpleTensor< char > &in, const TensorShape &output_shape, const GEMMLHSMatrixInfo &lhs_info)
template<typename T >
SimpleTensor< T >	gemm_reshape_rhs_matrix (const SimpleTensor< T > &in, const TensorShape &output_shape, const GEMMRHSMatrixInfo &rhs_info)
template SimpleTensor< int >	gemm_reshape_rhs_matrix (const SimpleTensor< int > &in, const TensorShape &output_shape, const GEMMRHSMatrixInfo &rhs_info)
template SimpleTensor< short >	gemm_reshape_rhs_matrix (const SimpleTensor< short > &in, const TensorShape &output_shape, const GEMMRHSMatrixInfo &rhs_info)
template SimpleTensor< char >	gemm_reshape_rhs_matrix (const SimpleTensor< char > &in, const TensorShape &output_shape, const GEMMRHSMatrixInfo &rhs_info)
template<typename T >
SimpleTensor< T >	gemm_transpose_1xW (const SimpleTensor< T > &in)
template<typename T >
void	im2col_nchw (const SimpleTensor< T > &src, SimpleTensor< T > &dst, const Size2D &kernel_dims, const PadStrideInfo &conv_info, bool has_bias, unsigned int num_groups)
template<typename T >
void	im2col_nhwc (const SimpleTensor< T > &src, SimpleTensor< T > &dst, const Size2D &kernel_dims, const PadStrideInfo &conv_info, bool has_bias)
template<typename T >
void	im2col (const SimpleTensor< T > &src, SimpleTensor< T > &dst, const Size2D &kernel_dims, const PadStrideInfo &conv_info, bool has_bias, unsigned int num_groups)
template void	im2col (const SimpleTensor< uint8_t > &src, SimpleTensor< uint8_t > &dst, const Size2D &kernel_dims, const PadStrideInfo &conv_info, bool has_bias, unsigned int num_groups)
template void	im2col (const SimpleTensor< half > &src, SimpleTensor< half > &dst, const Size2D &kernel_dims, const PadStrideInfo &conv_info, bool has_bias, unsigned int num_groups)
template void	im2col (const SimpleTensor< float > &src, SimpleTensor< float > &dst, const Size2D &kernel_dims, const PadStrideInfo &conv_info, bool has_bias, unsigned int num_groups)
SimpleTensor< int32_t >	indirect_conv2d_addr_precalculation (const TensorShape &shape_conv_src, const TensorShape &shape_conv_wei, const TensorShape &shape_conv_dst, const TensorShape &shape_dst, const PadStrideInfo &conv_info)
template<typename T >
SimpleTensor< T >	instance_normalization (const SimpleTensor< T > &src, float gamma, float beta, float epsilon)
template SimpleTensor< float >	instance_normalization (const SimpleTensor< float > &src, float gamma, float beta, float epsilon)
template SimpleTensor< half >	instance_normalization (const SimpleTensor< half > &src, float gamma, float beta, float epsilon)
template<typename T >
SimpleTensor< T >	l2_normalize (const SimpleTensor< T > &src, unsigned int axis, float epsilon)
template SimpleTensor< float >	l2_normalize (const SimpleTensor< float > &src, unsigned int axis, float epsilon)
template SimpleTensor< half >	l2_normalize (const SimpleTensor< half > &src, unsigned int axis, float epsilon)
template<typename T >
T	logical_binary_op (arm_compute::LogicalOperation op, T src1, T src2)
template<typename T >
SimpleTensor< T >	logical_or (const SimpleTensor< T > &src1, const SimpleTensor< T > &src2)
template<typename T >
SimpleTensor< T >	logical_and (const SimpleTensor< T > &src1, const SimpleTensor< T > &src2)
template<typename T >
SimpleTensor< T >	logical_not (const SimpleTensor< T > &src)
template SimpleTensor< uint8_t >	logical_or (const SimpleTensor< uint8_t > &src1, const SimpleTensor< uint8_t > &src2)
template SimpleTensor< uint8_t >	logical_and (const SimpleTensor< uint8_t > &src1, const SimpleTensor< uint8_t > &src2)
template SimpleTensor< uint8_t >	logical_not (const SimpleTensor< uint8_t > &src1)
template<typename T >
SimpleTensor< T >	max_unpooling_layer_internal (const SimpleTensor< T > &src, const PoolingLayerInfo &info, const QuantizationInfo &output_qinfo, SimpleTensor< uint32_t > &indices, TensorShape output_shape, DataLayout data_layout)
template<>
SimpleTensor< uint8_t >	max_unpooling_layer< uint8_t > (const SimpleTensor< uint8_t > &src, const PoolingLayerInfo &info, const QuantizationInfo &output_qinfo, SimpleTensor< uint32_t > &indices, TensorShape output_shape, DataLayout data_layout)
template<typename T >
SimpleTensor< T >	max_unpooling_layer (const SimpleTensor< T > &src, const PoolingLayerInfo &info, const QuantizationInfo &output_qinfo, SimpleTensor< uint32_t > &indices, TensorShape output_shape, DataLayout data_layout)
template SimpleTensor< float >	max_unpooling_layer (const SimpleTensor< float > &src, const PoolingLayerInfo &info, const QuantizationInfo &output_qinfo, SimpleTensor< uint32_t > &indices, TensorShape output_shape, DataLayout data_layout)
template SimpleTensor< half >	max_unpooling_layer (const SimpleTensor< half > &src, const PoolingLayerInfo &info, const QuantizationInfo &output_qinfo, SimpleTensor< uint32_t > &indices, TensorShape output_shape, DataLayout data_layout)
template<typename T >
std::pair< float, float >	mean_and_standard_deviation (const SimpleTensor< T > &in)
template std::pair< float, float >	mean_and_standard_deviation (const SimpleTensor< uint8_t > &in)
template std::pair< float, float >	mean_and_standard_deviation (const SimpleTensor< half > &in)
template std::pair< float, float >	mean_and_standard_deviation (const SimpleTensor< float > &in)
template<typename T >
SimpleTensor< T >	mean_std_normalization_layer (const SimpleTensor< T > &src, float epsilon)
template<>
SimpleTensor< uint8_t >	mean_std_normalization_layer (const SimpleTensor< uint8_t > &src, float epsilon)
template SimpleTensor< float >	mean_std_normalization_layer (const SimpleTensor< float > &src, float epsilon)
template SimpleTensor< half >	mean_std_normalization_layer (const SimpleTensor< half > &src, float epsilon)
template<typename T >
void	compute_min_max (const SimpleTensor< T > &src, T &min, T &max)
template<typename T >
MinMaxLocationValues< T >	min_max_location (const SimpleTensor< T > &src)
template MinMaxLocationValues< uint8_t >	min_max_location (const SimpleTensor< uint8_t > &src)
template MinMaxLocationValues< int16_t >	min_max_location (const SimpleTensor< int16_t > &src)
template MinMaxLocationValues< float >	min_max_location (const SimpleTensor< float > &src)
template<typename T >
SimpleTensor< T >	non_maxima_suppression (const SimpleTensor< T > &src, BorderMode border_mode, T constant_border_value)
template SimpleTensor< float >	non_maxima_suppression (const SimpleTensor< float > &src, BorderMode border_mode, float constant_border_value)
template SimpleTensor< uint8_t >	non_maxima_suppression (const SimpleTensor< uint8_t > &src, BorderMode border_mode, uint8_t constant_border_value)
SimpleTensor< int >	non_max_suppression (const SimpleTensor< float > &bboxes, const SimpleTensor< float > &scores, SimpleTensor< int > &indices, unsigned int max_output_size, float score_threshold, float nms_threshold)
template<typename T >
SimpleTensor< T >	normalization_layer (const SimpleTensor< T > &src, NormalizationLayerInfo info)
template SimpleTensor< float >	normalization_layer (const SimpleTensor< float > &src, NormalizationLayerInfo info)
template SimpleTensor< half >	normalization_layer (const SimpleTensor< half > &src, NormalizationLayerInfo info)
template<typename T >
SimpleTensor< T >	normalize_planar_yuv_layer (const SimpleTensor< T > &src, const SimpleTensor< T > &mean, const SimpleTensor< T > &std)
template<>
SimpleTensor< uint8_t >	normalize_planar_yuv_layer< uint8_t > (const SimpleTensor< uint8_t > &src, const SimpleTensor< uint8_t > &mean, const SimpleTensor< uint8_t > &std)
template<>
SimpleTensor< int8_t >	normalize_planar_yuv_layer< int8_t > (const SimpleTensor< int8_t > &src, const SimpleTensor< int8_t > &mean, const SimpleTensor< int8_t > &std)
template SimpleTensor< half >	normalize_planar_yuv_layer (const SimpleTensor< half > &src, const SimpleTensor< half > &mean, const SimpleTensor< half > &std)
template SimpleTensor< float >	normalize_planar_yuv_layer (const SimpleTensor< float > &src, const SimpleTensor< float > &mean, const SimpleTensor< float > &std)
template<typename T >
SimpleTensor< T >	pad_layer (const SimpleTensor< T > &src, const PaddingList &paddings, const PixelValue const_value=PixelValue(), const PaddingMode mode=PaddingMode::CONSTANT)
	Reference function to pad an ND tensor. More...
template SimpleTensor< float >	pad_layer (const SimpleTensor< float > &src, const PaddingList &paddings, const PixelValue const_value=PixelValue(), const PaddingMode mode)
template SimpleTensor< half >	pad_layer (const SimpleTensor< half > &src, const PaddingList &paddings, const PixelValue const_value=PixelValue(), const PaddingMode mode)
template SimpleTensor< uint8_t >	pad_layer (const SimpleTensor< uint8_t > &src, const PaddingList &paddings, const PixelValue const_value=PixelValue(), const PaddingMode mode)
template SimpleTensor< int8_t >	pad_layer (const SimpleTensor< int8_t > &src, const PaddingList &paddings, const PixelValue const_value=PixelValue(), const PaddingMode mode)
template SimpleTensor< uint16_t >	pad_layer (const SimpleTensor< uint16_t > &src, const PaddingList &paddings, const PixelValue const_value=PixelValue(), const PaddingMode mode)
template SimpleTensor< int16_t >	pad_layer (const SimpleTensor< int16_t > &src, const PaddingList &paddings, const PixelValue const_value=PixelValue(), const PaddingMode mode)
template SimpleTensor< uint32_t >	pad_layer (const SimpleTensor< uint32_t > &src, const PaddingList &paddings, const PixelValue const_value=PixelValue(), const PaddingMode mode)
template SimpleTensor< int32_t >	pad_layer (const SimpleTensor< int32_t > &src, const PaddingList &paddings, const PixelValue const_value=PixelValue(), const PaddingMode mode)
template<typename T >
SimpleTensor< T >	permute (const SimpleTensor< T > &src, PermutationVector perm)
template SimpleTensor< int8_t >	permute (const SimpleTensor< int8_t > &src, PermutationVector perm)
template SimpleTensor< uint8_t >	permute (const SimpleTensor< uint8_t > &src, PermutationVector perm)
template SimpleTensor< int16_t >	permute (const SimpleTensor< int16_t > &src, PermutationVector perm)
template SimpleTensor< uint16_t >	permute (const SimpleTensor< uint16_t > &src, PermutationVector perm)
template SimpleTensor< uint32_t >	permute (const SimpleTensor< uint32_t > &src, PermutationVector perm)
template SimpleTensor< float >	permute (const SimpleTensor< float > &src, PermutationVector perm)
template SimpleTensor< half >	permute (const SimpleTensor< half > &src, PermutationVector perm)
template<typename T1 , typename T2 , typename T3 >
SimpleTensor< T3 >	pixel_wise_multiplication (const SimpleTensor< T1 > &src1, const SimpleTensor< T2 > &src2, float scale, ConvertPolicy convert_policy, RoundingPolicy rounding_policy, DataType dt_out, const QuantizationInfo &qout)
template<>
SimpleTensor< uint8_t >	pixel_wise_multiplication (const SimpleTensor< uint8_t > &src1, const SimpleTensor< uint8_t > &src2, float scale, ConvertPolicy convert_policy, RoundingPolicy rounding_policy, DataType dt_out, const QuantizationInfo &qout)
template<>
SimpleTensor< int8_t >	pixel_wise_multiplication (const SimpleTensor< int8_t > &src1, const SimpleTensor< int8_t > &src2, float scale, ConvertPolicy convert_policy, RoundingPolicy rounding_policy, DataType dt_out, const QuantizationInfo &qout)
template<>
SimpleTensor< int16_t >	pixel_wise_multiplication (const SimpleTensor< int16_t > &src1, const SimpleTensor< int16_t > &src2, float scale, ConvertPolicy convert_policy, RoundingPolicy rounding_policy, DataType dt_out, const QuantizationInfo &qout)
template SimpleTensor< int16_t >	pixel_wise_multiplication (const SimpleTensor< uint8_t > &src1, const SimpleTensor< int16_t > &src2, float scale, ConvertPolicy convert_policy, RoundingPolicy rounding_policy, DataType dt_out, const QuantizationInfo &qout)
template SimpleTensor< int32_t >	pixel_wise_multiplication (const SimpleTensor< int32_t > &src1, const SimpleTensor< int32_t > &src2, float scale, ConvertPolicy convert_policy, RoundingPolicy rounding_policy, DataType dt_out, const QuantizationInfo &qout)
template SimpleTensor< float >	pixel_wise_multiplication (const SimpleTensor< float > &src1, const SimpleTensor< float > &src2, float scale, ConvertPolicy convert_policy, RoundingPolicy rounding_policy, DataType dt_out, const QuantizationInfo &qout)
template SimpleTensor< half_float::half >	pixel_wise_multiplication (const SimpleTensor< half_float::half > &src1, const SimpleTensor< half_float::half > &src2, float scale, ConvertPolicy convert_policy, RoundingPolicy rounding_policy, DataType dt_out, const QuantizationInfo &qout)
template<typename T >
SimpleTensor< T >	pooling_3d_layer_internal (const SimpleTensor< T > &src, const Pooling3dLayerInfo &pool3d_info, SimpleTensor< uint32_t > *indices)
template SimpleTensor< float >	pooling_3d_layer (const SimpleTensor< float > &src, const Pooling3dLayerInfo &pool3d_info, const QuantizationInfo &output_qinfo, SimpleTensor< uint32_t > *indices)
template SimpleTensor< half >	pooling_3d_layer (const SimpleTensor< half > &src, const Pooling3dLayerInfo &pool3d_info, const QuantizationInfo &output_qinfo, SimpleTensor< uint32_t > *indices)
template<typename T >
SimpleTensor< T >	pooling_3d_layer (const SimpleTensor< T > &src, const Pooling3dLayerInfo &pool3d_info, const QuantizationInfo &output_qinfo, SimpleTensor< uint32_t > *indices)
template<>
SimpleTensor< int8_t >	pooling_3d_layer< int8_t > (const SimpleTensor< int8_t > &src, const Pooling3dLayerInfo &pool3d_info, const QuantizationInfo &output_qinfo, SimpleTensor< uint32_t > *indices)
template<>
SimpleTensor< uint8_t >	pooling_3d_layer< uint8_t > (const SimpleTensor< uint8_t > &src, const Pooling3dLayerInfo &pool3d_info, const QuantizationInfo &output_qinfo, SimpleTensor< uint32_t > *indices)
template<typename T , typename ACC_T , typename std::enable_if< is_floating_point< T >::value, int >::type >
SimpleTensor< T >	pooling_layer_internal (const SimpleTensor< T > &src, const PoolingLayerInfo &info, SimpleTensor< uint32_t > *indices, DataLayout data_layout)
template SimpleTensor< float >	pooling_layer_internal< float > (const SimpleTensor< float > &src, const PoolingLayerInfo &info, SimpleTensor< uint32_t > *indices, DataLayout data_layout)
template SimpleTensor< half >	pooling_layer_internal< half > (const SimpleTensor< half > &src, const PoolingLayerInfo &info, SimpleTensor< uint32_t > *indices, DataLayout data_layout)
template SimpleTensor< half >	pooling_layer_internal< half, float > (const SimpleTensor< half > &src, const PoolingLayerInfo &info, SimpleTensor< uint32_t > *indices, DataLayout data_layout)
template<typename T >
SimpleTensor< T >	pooling_layer (const SimpleTensor< T > &src, const PoolingLayerInfo &info, const QuantizationInfo &output_qinfo, SimpleTensor< uint32_t > *indices, DataLayout data_layout)
template<>
SimpleTensor< uint8_t >	pooling_layer< uint8_t > (const SimpleTensor< uint8_t > &src, const PoolingLayerInfo &info, const QuantizationInfo &output_qinfo, SimpleTensor< uint32_t > *indices, DataLayout data_layout)
template<>
SimpleTensor< int8_t >	pooling_layer< int8_t > (const SimpleTensor< int8_t > &src, const PoolingLayerInfo &info, const QuantizationInfo &output_qinfo, SimpleTensor< uint32_t > *indices, DataLayout data_layout)
template<>
SimpleTensor< half >	pooling_layer (const SimpleTensor< half > &src, const PoolingLayerInfo &info, const QuantizationInfo &output_qinfo, SimpleTensor< uint32_t > *indices, DataLayout data_layout)
template SimpleTensor< float >	pooling_layer (const SimpleTensor< float > &src, const PoolingLayerInfo &info, const QuantizationInfo &output_qinfo, SimpleTensor< uint32_t > *indices, DataLayout data_layout)
template<typename T , typename std::enable_if< is_floating_point< T >::value, int >::type >
SimpleTensor< T >	post_ops (const SimpleTensor< T > &a, experimental::PostOpList< SimpleTensor< T >> post_ops)
	(EXPERIMENTAL_POST_OPS) More...
template SimpleTensor< float >	post_ops (const SimpleTensor< float > &a, experimental::PostOpList< SimpleTensor< float >> post_ops)
template SimpleTensor< half >	post_ops (const SimpleTensor< half > &a, experimental::PostOpList< SimpleTensor< half >> post_ops)
template<typename T >
SimpleTensor< T >	prior_box_layer (const SimpleTensor< T > &src1, const SimpleTensor< T > &src2, const PriorBoxLayerInfo &info, const TensorShape &output_shape)
template SimpleTensor< float >	prior_box_layer (const SimpleTensor< float > &src1, const SimpleTensor< float > &src2, const PriorBoxLayerInfo &info, const TensorShape &output_shape)
SimpleTensor< int16_t >	qlstm_layer_normalization (const SimpleTensor< int16_t > &src, const SimpleTensor< int16_t > &weight, const SimpleTensor< int32_t > &bias)
template<typename Tin , typename Tout >
SimpleTensor< Tout >	quantization_layer (const SimpleTensor< Tin > &src, DataType output_data_type, const QuantizationInfo &quantization_info)
template<>
SimpleTensor< uint8_t >	quantization_layer (const SimpleTensor< uint8_t > &src, DataType output_data_type, const QuantizationInfo &quantization_info)
template<>
SimpleTensor< uint8_t >	quantization_layer (const SimpleTensor< int8_t > &src, DataType output_data_type, const QuantizationInfo &quantization_info)
template SimpleTensor< int8_t >	quantization_layer (const SimpleTensor< half > &src, DataType output_data_type, const QuantizationInfo &quantization_info)
template SimpleTensor< int8_t >	quantization_layer (const SimpleTensor< float > &src, DataType output_data_type, const QuantizationInfo &quantization_info)
template<typename T >
SimpleTensor< T >	range (SimpleTensor< T > &dst, float start, const size_t num_of_elements, float step)
template<>
SimpleTensor< uint8_t >	range (SimpleTensor< uint8_t > &dst, float start, const size_t num_of_elements, float step)
template SimpleTensor< float >	range (SimpleTensor< float > &dst, float start, const size_t num_of_elements, float step)
template SimpleTensor< half >	range (SimpleTensor< half > &dst, float start, const size_t num_of_elements, float step)
template SimpleTensor< int8_t >	range (SimpleTensor< int8_t > &dst, float start, const size_t num_of_elements, float step)
template SimpleTensor< uint16_t >	range (SimpleTensor< uint16_t > &dst, float start, const size_t num_of_elements, float step)
template SimpleTensor< int16_t >	range (SimpleTensor< int16_t > &dst, float start, const size_t num_of_elements, float step)
template<typename T , typename OT >
SimpleTensor< OT >	compute_reduction_operation (const SimpleTensor< T > &src, const TensorShape &dst_shape, unsigned int axis, ReductionOperation op, DataType output_type, RoundingPolicy policy)
template<typename T , typename OT >
SimpleTensor< OT >	reduction_operation (const SimpleTensor< T > &src, const TensorShape &dst_shape, unsigned int axis, ReductionOperation op, DataType output_type, QuantizationInfo quantization_info_output, RoundingPolicy policy)
template<>
SimpleTensor< uint8_t >	reduction_operation (const SimpleTensor< uint8_t > &src, const TensorShape &dst_shape, unsigned int axis, ReductionOperation op, DataType output_type, QuantizationInfo quantization_info_output, RoundingPolicy policy)
template<>
SimpleTensor< int8_t >	reduction_operation (const SimpleTensor< int8_t > &src, const TensorShape &dst_shape, unsigned int axis, ReductionOperation op, DataType output_type, QuantizationInfo quantization_info_output, RoundingPolicy policy)
template SimpleTensor< float >	reduction_operation (const SimpleTensor< float > &src, const TensorShape &dst_shape, unsigned int axis, ReductionOperation op, DataType output_type=DataType::S32, QuantizationInfo quantization_info_output=QuantizationInfo(), RoundingPolicy policy=RoundingPolicy::TO_ZERO)
template SimpleTensor< half >	reduction_operation (const SimpleTensor< half > &src, const TensorShape &dst_shape, unsigned int axis, ReductionOperation op, DataType output_type=DataType::S32, QuantizationInfo quantization_info_output=QuantizationInfo(), RoundingPolicy policy=RoundingPolicy::TO_ZERO)
template SimpleTensor< int32_t >	reduction_operation (const SimpleTensor< int32_t > &src, const TensorShape &dst_shape, unsigned int axis, ReductionOperation op, DataType output_type=DataType::S32, QuantizationInfo quantization_info_output=QuantizationInfo(), RoundingPolicy policy=RoundingPolicy::TO_ZERO)
template<typename T >
SimpleTensor< T >	reorder_layer (const SimpleTensor< T > &src, const TensorShape &output_shape, WeightFormat output_wf)
template SimpleTensor< float >	reorder_layer (const SimpleTensor< float > &src, const TensorShape &output_shape, WeightFormat output_wf)
template<typename T >
SimpleTensor< T >	reorg_layer (const SimpleTensor< T > &src, int32_t stride)
template SimpleTensor< int32_t >	reorg_layer (const SimpleTensor< int32_t > &src, int32_t stride)
template SimpleTensor< int16_t >	reorg_layer (const SimpleTensor< int16_t > &src, int32_t stride)
template SimpleTensor< int8_t >	reorg_layer (const SimpleTensor< int8_t > &src, int32_t stride)
template<typename T >
SimpleTensor< T >	reshape_layer (const SimpleTensor< T > &src, const TensorShape &output_shape)
	[ReshapeLayer] More...
template SimpleTensor< uint8_t >	reshape_layer (const SimpleTensor< uint8_t > &src, const TensorShape &output_shape)
template SimpleTensor< int8_t >	reshape_layer (const SimpleTensor< int8_t > &src, const TensorShape &output_shape)
template SimpleTensor< uint16_t >	reshape_layer (const SimpleTensor< uint16_t > &src, const TensorShape &output_shape)
template SimpleTensor< int16_t >	reshape_layer (const SimpleTensor< int16_t > &src, const TensorShape &output_shape)
template SimpleTensor< uint32_t >	reshape_layer (const SimpleTensor< uint32_t > &src, const TensorShape &output_shape)
template SimpleTensor< int32_t >	reshape_layer (const SimpleTensor< int32_t > &src, const TensorShape &output_shape)
template SimpleTensor< half >	reshape_layer (const SimpleTensor< half > &src, const TensorShape &output_shape)
template SimpleTensor< float >	reshape_layer (const SimpleTensor< float > &src, const TensorShape &output_shape)
template<typename T >
SimpleTensor< T >	reverse (const SimpleTensor< T > &src, const SimpleTensor< uint32_t > &axis)
template SimpleTensor< uint8_t >	reverse (const SimpleTensor< uint8_t > &src, const SimpleTensor< uint32_t > &axis)
template SimpleTensor< half >	reverse (const SimpleTensor< half > &src, const SimpleTensor< uint32_t > &axis)
template SimpleTensor< float >	reverse (const SimpleTensor< float > &src, const SimpleTensor< uint32_t > &axis)
template<>
SimpleTensor< float >	roi_align_layer (const SimpleTensor< float > &src, const SimpleTensor< float > &rois, const ROIPoolingLayerInfo &pool_info, const QuantizationInfo &output_qinfo)
template<>
SimpleTensor< half >	roi_align_layer (const SimpleTensor< half > &src, const SimpleTensor< half > &rois, const ROIPoolingLayerInfo &pool_info, const QuantizationInfo &output_qinfo)
template<>
SimpleTensor< uint8_t >	roi_align_layer (const SimpleTensor< uint8_t > &src, const SimpleTensor< uint16_t > &rois, const ROIPoolingLayerInfo &pool_info, const QuantizationInfo &output_qinfo)
template<>
SimpleTensor< int8_t >	roi_align_layer (const SimpleTensor< int8_t > &src, const SimpleTensor< uint16_t > &rois, const ROIPoolingLayerInfo &pool_info, const QuantizationInfo &output_qinfo)
template<typename T , typename TRois >
SimpleTensor< T >	roi_align_layer (const SimpleTensor< T > &src, const SimpleTensor< TRois > &rois, const ROIPoolingLayerInfo &pool_info, const QuantizationInfo &output_qinfo)
template<>
SimpleTensor< float >	roi_pool_layer (const SimpleTensor< float > &src, const SimpleTensor< uint16_t > &rois, const ROIPoolingLayerInfo &pool_info, const QuantizationInfo &output_qinfo)
template<>
SimpleTensor< uint8_t >	roi_pool_layer (const SimpleTensor< uint8_t > &src, const SimpleTensor< uint16_t > &rois, const ROIPoolingLayerInfo &pool_info, const QuantizationInfo &output_qinfo)
template<typename T >
SimpleTensor< T >	roi_pool_layer (const SimpleTensor< T > &src, const SimpleTensor< uint16_t > &rois, const ROIPoolingLayerInfo &pool_info, const QuantizationInfo &output_qinfo)
template<typename T >
SimpleTensor< T >	scale_core (const SimpleTensor< T > &in, float scale_x, float scale_y, InterpolationPolicy policy, BorderMode border_mode, T constant_border_value, SamplingPolicy sampling_policy, bool ceil_policy_scale, bool align_corners)
template<typename T >
SimpleTensor< T >	scale (const SimpleTensor< T > &src, float scale_x, float scale_y, InterpolationPolicy policy, BorderMode border_mode, T constant_border_value, SamplingPolicy sampling_policy, bool ceil_policy_scale, bool align_corners, QuantizationInfo output_quantization_info)
template<>
SimpleTensor< uint8_t >	scale (const SimpleTensor< uint8_t > &src, float scale_x, float scale_y, InterpolationPolicy policy, BorderMode border_mode, uint8_t constant_border_value, SamplingPolicy sampling_policy, bool ceil_policy_scale, bool align_corners, QuantizationInfo output_quantization_info)
template<>
SimpleTensor< int8_t >	scale (const SimpleTensor< int8_t > &src, float scale_x, float scale_y, InterpolationPolicy policy, BorderMode border_mode, int8_t constant_border_value, SamplingPolicy sampling_policy, bool ceil_policy_scale, bool align_corners, QuantizationInfo output_quantization_info)
template SimpleTensor< int16_t >	scale (const SimpleTensor< int16_t > &src, float scale_x, float scale_y, InterpolationPolicy policy, BorderMode border_mode, int16_t constant_border_value, SamplingPolicy sampling_policy, bool ceil_policy_scale, bool align_corners, QuantizationInfo output_quantization_info)
template SimpleTensor< half >	scale (const SimpleTensor< half > &src, float scale_x, float scale_y, InterpolationPolicy policy, BorderMode border_mode, half constant_border_value, SamplingPolicy sampling_policy, bool ceil_policy_scale, bool align_corners, QuantizationInfo output_quantization_info)
template SimpleTensor< float >	scale (const SimpleTensor< float > &src, float scale_x, float scale_y, InterpolationPolicy policy, BorderMode border_mode, float constant_border_value, SamplingPolicy sampling_policy, bool ceil_policy_scale, bool align_corners, QuantizationInfo output_quantization_info)
template<typename T >
SimpleTensor< T >	select (const SimpleTensor< uint8_t > &c, const SimpleTensor< T > &x, const SimpleTensor< T > &y)
template SimpleTensor< uint8_t >	select (const SimpleTensor< uint8_t > &c, const SimpleTensor< uint8_t > &x, const SimpleTensor< uint8_t > &y)
template SimpleTensor< half >	select (const SimpleTensor< uint8_t > &c, const SimpleTensor< half > &x, const SimpleTensor< half > &y)
template SimpleTensor< float >	select (const SimpleTensor< uint8_t > &c, const SimpleTensor< float > &x, const SimpleTensor< float > &y)
template<typename T >
SimpleTensor< T >	slice (const SimpleTensor< T > &src, Coordinates starts, Coordinates ends)
template SimpleTensor< float >	slice (const SimpleTensor< float > &src, Coordinates starts, Coordinates ends)
template SimpleTensor< half_float::half >	slice (const SimpleTensor< half_float::half > &src, Coordinates starts, Coordinates ends)
template<typename T >
SimpleTensor< T >	strided_slice (const SimpleTensor< T > &src, Coordinates starts, Coordinates ends, BiStrides strides, int32_t begin_mask, int32_t end_mask, int32_t shrink_axis_mask)
template SimpleTensor< float >	strided_slice (const SimpleTensor< float > &src, Coordinates starts, Coordinates ends, BiStrides strides, int32_t begin_mask, int32_t end_mask, int32_t shrink_axis_mask)
template SimpleTensor< half_float::half >	strided_slice (const SimpleTensor< half_float::half > &src, Coordinates starts, Coordinates ends, BiStrides strides, int32_t begin_mask, int32_t end_mask, int32_t shrink_axis_mask)
template<typename T , typename std::enable_if< is_floating_point< T >::value, int >::type >
SimpleTensor< T >	softmax_layer_generic (const SimpleTensor< T > &src, float beta, int32_t axis, bool is_log)
template SimpleTensor< float >	softmax_layer_generic (const SimpleTensor< float > &src, float beta, int32_t axis, bool is_log)
template SimpleTensor< half >	softmax_layer_generic (const SimpleTensor< half > &src, float beta, int32_t axis, bool is_log)
template<typename T , typename std::enable_if< is_floating_point< T >::value, int >::type >
SimpleTensor< T >	softmax_layer (const SimpleTensor< T > &src, float beta, int32_t axis, bool is_log)
template SimpleTensor< float >	softmax_layer (const SimpleTensor< float > &src, float beta, int32_t axis, bool is_log)
template SimpleTensor< half >	softmax_layer (const SimpleTensor< half > &src, float beta, int32_t axis, bool is_log)
template SimpleTensor< uint8_t >	softmax_layer (const SimpleTensor< uint8_t > &src, float beta, int32_t axis, bool is_log)
template SimpleTensor< int8_t >	softmax_layer (const SimpleTensor< int8_t > &src, float beta, int32_t axis, bool is_log)
template<typename T >
SimpleTensor< T >	space_to_batch (const SimpleTensor< T > &src, const SimpleTensor< int32_t > &block_shape, const SimpleTensor< int32_t > &paddings, const TensorShape &dst_shape)
template SimpleTensor< float >	space_to_batch (const SimpleTensor< float > &src, const SimpleTensor< int32_t > &block_shape, const SimpleTensor< int32_t > &paddings, const TensorShape &dst_shape)
template SimpleTensor< half >	space_to_batch (const SimpleTensor< half > &src, const SimpleTensor< int32_t > &block_shape, const SimpleTensor< int32_t > &paddings, const TensorShape &dst_shape)
template SimpleTensor< uint8_t >	space_to_batch (const SimpleTensor< uint8_t > &src, const SimpleTensor< int32_t > &block_shape, const SimpleTensor< int32_t > &paddings, const TensorShape &dst_shape)
template<typename T >
SimpleTensor< T >	space_to_depth (const SimpleTensor< T > &src, const TensorShape &dst_shape, const int block_shape)
template SimpleTensor< float >	space_to_depth (const SimpleTensor< float > &src, const TensorShape &dst_shape, const int block_shape)
template SimpleTensor< half >	space_to_depth (const SimpleTensor< half > &src, const TensorShape &dst_shape, const int block_shape)
template<typename T >
SimpleTensor< T >	stack_layer (const std::vector< SimpleTensor< T >> &in, const TensorShape &output_shape, DataType data_type, unsigned int axis)
template SimpleTensor< int >	stack_layer (const std::vector< SimpleTensor< int >> &in, const TensorShape &output_shape, DataType data_type, unsigned int axis)
template SimpleTensor< short >	stack_layer (const std::vector< SimpleTensor< short >> &in, const TensorShape &output_shape, DataType data_type, unsigned int axis)
template SimpleTensor< char >	stack_layer (const std::vector< SimpleTensor< char >> &in, const TensorShape &output_shape, DataType data_type, unsigned int axis)
template<typename T >
SimpleTensor< T >	table_lookup (const SimpleTensor< T > &src, const std::map< T, T > &rawlut)
template SimpleTensor< uint8_t >	table_lookup (const SimpleTensor< uint8_t > &src, const std::map< uint8_t, uint8_t > &rawlut)
template SimpleTensor< int16_t >	table_lookup (const SimpleTensor< int16_t > &src, const std::map< int16_t, int16_t > &rawlut)
template<typename T >
SimpleTensor< T >	tile (const SimpleTensor< T > &src, const Multiples &multiples)
template SimpleTensor< uint8_t >	tile (const SimpleTensor< uint8_t > &src, const Multiples &multiples)
template SimpleTensor< int8_t >	tile (const SimpleTensor< int8_t > &src, const Multiples &multiples)
template SimpleTensor< uint16_t >	tile (const SimpleTensor< uint16_t > &src, const Multiples &multiples)
template SimpleTensor< int16_t >	tile (const SimpleTensor< int16_t > &src, const Multiples &multiples)
template SimpleTensor< uint32_t >	tile (const SimpleTensor< uint32_t > &src, const Multiples &multiples)
template SimpleTensor< int32_t >	tile (const SimpleTensor< int32_t > &src, const Multiples &multiples)
template SimpleTensor< half >	tile (const SimpleTensor< half > &src, const Multiples &multiples)
template SimpleTensor< float >	tile (const SimpleTensor< float > &src, const Multiples &multiples)
template<typename T >
SimpleTensor< T >	transpose (const SimpleTensor< T > &src)
template SimpleTensor< uint8_t >	transpose (const SimpleTensor< uint8_t > &src)
template SimpleTensor< uint16_t >	transpose (const SimpleTensor< uint16_t > &src)
template SimpleTensor< uint32_t >	transpose (const SimpleTensor< uint32_t > &src)
template SimpleTensor< half >	transpose (const SimpleTensor< half > &src)
template SimpleTensor< float >	transpose (const SimpleTensor< float > &src)
template<typename T >
std::vector< SimpleTensor< T > >	unstack (const SimpleTensor< T > &input_tensor, std::vector< SimpleTensor< T >> &output_tensors, int axis)
template std::vector< SimpleTensor< float > >	unstack (const SimpleTensor< float > &input_tensor, std::vector< SimpleTensor< float >> &output_tensors, int axis)
template std::vector< SimpleTensor< half > >	unstack (const SimpleTensor< half > &input_tensor, std::vector< SimpleTensor< half >> &output_tensors, int axis)
template std::vector< SimpleTensor< uint8_t > >	unstack (const SimpleTensor< uint8_t > &input_tensor, std::vector< SimpleTensor< uint8_t >> &output_tensors, int axis)
template<typename T >
SimpleTensor< T >	weights_reshape (const SimpleTensor< T > &src, const SimpleTensor< T > &biases, const TensorShape &dst_shape, const unsigned int num_groups)
template SimpleTensor< float >	weights_reshape (const SimpleTensor< float > &src, const SimpleTensor< float > &biases, const TensorShape &dst_shape, const unsigned int num_groups)
template SimpleTensor< half >	weights_reshape (const SimpleTensor< half > &src, const SimpleTensor< half > &biases, const TensorShape &dst_shape, const unsigned int num_groups)
template SimpleTensor< uint8_t >	weights_reshape (const SimpleTensor< uint8_t > &src, const SimpleTensor< uint8_t > &biases, const TensorShape &dst_shape, const unsigned int num_groups)
template<typename T >
SimpleTensor< T >	winograd_input_transform (const SimpleTensor< T > &in, const TensorShape &output_shape, const WinogradInfo &winograd_info)
template<typename T >
SimpleTensor< T >	winograd_filter_transform (const SimpleTensor< T > &in, const TensorShape &output_shape, const WinogradInfo &winograd_info)
template<typename T >
SimpleTensor< T >	winograd_output_transform (const SimpleTensor< T > &in, const SimpleTensor< T > &b, const TensorShape &output_shape, const WinogradInfo &winograd_info)
template SimpleTensor< float >	winograd_filter_transform (const SimpleTensor< float > &in, const TensorShape &output_shape, const WinogradInfo &winograd_info)
template SimpleTensor< float >	winograd_input_transform (const SimpleTensor< float > &in, const TensorShape &output_shape, const WinogradInfo &winograd_info)
template SimpleTensor< float >	winograd_output_transform (const SimpleTensor< float > &in, const SimpleTensor< float > &b, const TensorShape &output_shape, const WinogradInfo &winograd_info)
template SimpleTensor< half >	winograd_filter_transform (const SimpleTensor< half > &in, const TensorShape &output_shape, const WinogradInfo &winograd_info)
template SimpleTensor< half >	winograd_input_transform (const SimpleTensor< half > &in, const TensorShape &output_shape, const WinogradInfo &winograd_info)
template SimpleTensor< half >	winograd_output_transform (const SimpleTensor< half > &in, const SimpleTensor< half > &b, const TensorShape &output_shape, const WinogradInfo &winograd_info)

Enumeration Type Documentation

ArithmeticOperation

enum ArithmeticOperation

strong

Arithmetic operation types.

Enumerator
ADD
SUB

Definition at line 39 of file ArithmeticOperations.h.

{
    ADD,
    SUB
};

FFTDirection

enum FFTDirection

strong

Enumerator
Forward
Inverse

Definition at line 38 of file DFT.h.

{
    Forward,
    Inverse
};

WinogradTransformType

enum WinogradTransformType

strong

Winograd transform type.

Enumerator
INPUT	Winograd input transform.
FILTER	Winograd filter transform.
OUTPUT	Winograd output transform.

Definition at line 40 of file Winograd.h.

{
    INPUT,  /**< Winograd input transform */
    FILTER, /**< Winograd filter transform */
    OUTPUT  /**< Winograd output transform */
};

Function Documentation

absolute_difference() [1/4]

template SimpleTensor<int16_t> arm_compute::test::validation::reference::absolute_difference	(	const SimpleTensor< int16_t > &	src1,
		const SimpleTensor< int16_t > &	src2,
		DataType	dst_data_type
	)

absolute_difference() [2/4]

template SimpleTensor<int8_t> arm_compute::test::validation::reference::absolute_difference	(	const SimpleTensor< int8_t > &	src1,
		const SimpleTensor< int8_t > &	src2,
		DataType	dst_data_type
	)

absolute_difference() [3/4]

SimpleTensor< T > absolute_difference	(	const SimpleTensor< T > &	src1,
		const SimpleTensor< T > &	src2,
		DataType	dst_data_type
	)

Definition at line 38 of file AbsoluteDifference.cpp.

{
    SimpleTensor<T> result(src1.shape(), dst_data_type);
 
    using intermediate_type = typename common_promoted_signed_type<T>::intermediate_type;
#if defined(_OPENMP)
    #pragma omp parallel for
#endif /* _OPENMP */
    for(int i = 0; i < src1.num_elements(); ++i)
    {
        intermediate_type val = std::abs(static_cast<intermediate_type>(src1[i]) - static_cast<intermediate_type>(src2[i]));
        result[i]             = saturate_cast<T>(val);
    }
 
    return result;
}

References SimpleTensor< T >::num_elements(), and SimpleTensor< T >::shape().

absolute_difference() [4/4]

template SimpleTensor<uint8_t> arm_compute::test::validation::reference::absolute_difference	(	const SimpleTensor< uint8_t > &	src1,
		const SimpleTensor< uint8_t > &	src2,
		DataType	dst_data_type
	)

accumulate() [1/2]

SimpleTensor< T2 > accumulate	(	const SimpleTensor< T1 > &	src,
		DataType	output_data_type
	)

Definition at line 38 of file Accumulate.cpp.

{
    SimpleTensor<T2> dst{ src.shape(), output_data_type };
 
    library->fill_tensor_uniform(dst, 1, static_cast<T2>(0), static_cast<T2>(std::numeric_limits<T1>::max()));
 
    using intermediate_type = typename common_promoted_signed_type<T1, T2>::intermediate_type;
#if defined(_OPENMP)
    #pragma omp parallel for
#endif /* _OPENMP */
    for(int i = 0; i < src.num_elements(); ++i)
    {
        intermediate_type val = static_cast<intermediate_type>(src[i]) + static_cast<intermediate_type>(dst[i]);
        dst[i]                = saturate_cast<T2>(val);
    }
 
    return dst;
}

References arm_compute::test::validation::dst, arm_compute::test::library, and arm_compute::test::validation::src.

Referenced by Dimensions< size_t >::collapse(), arm_compute::detail::convolve_3x3(), arm_compute::helpers::fft::digit_reverse_indices(), InstrumentsStats::InstrumentsStats(), arm_compute::join(), arm_compute::test::join(), mean_and_standard_deviation(), arm_compute::scale_helpers::pixel_area_c1u8_clamp(), SimpleTensor< uint8_t >::size(), OpenCLMemoryUsage::test_measurements(), PostOpList< arm_compute::ITensorInfo * >::total_num_arguments(), TensorShape::total_size(), TensorShape::total_size_lower(), and TensorShape::total_size_upper().

accumulate() [2/2]

template SimpleTensor<int16_t> arm_compute::test::validation::reference::accumulate	(	const SimpleTensor< uint8_t > &	src,
		DataType	output_data_type
	)

accumulate_squared() [1/2]

SimpleTensor< T2 > accumulate_squared	(	const SimpleTensor< T1 > &	src,
		uint32_t	shift,
		DataType	output_data_type
	)

Definition at line 80 of file Accumulate.cpp.

{
    ARM_COMPUTE_ERROR_ON_MSG(shift > 15, "Shift in accumulate_squared must be within the range [0, 15]");
 
    SimpleTensor<T2> dst{ src.shape(), output_data_type };
 
    library->fill_tensor_uniform(dst, 1, static_cast<T2>(0), static_cast<T2>(std::numeric_limits<T1>::max()));
 
    using intermediate_type = typename common_promoted_signed_type<T1, T2>::intermediate_type;
    intermediate_type denom = 1 << shift;
#if defined(_OPENMP)
    #pragma omp parallel for
#endif /* _OPENMP */
    for(int i = 0; i < src.num_elements(); ++i)
    {
        intermediate_type val = static_cast<intermediate_type>(dst[i]) + (static_cast<intermediate_type>(src[i]) * static_cast<intermediate_type>(src[i]) / denom);
        dst[i]                = saturate_cast<T2>(val);
    }
 
    return dst;
}

References ARM_COMPUTE_ERROR_ON_MSG, arm_compute::test::validation::dst, arm_compute::test::library, and arm_compute::test::validation::src.

accumulate_squared() [2/2]

template SimpleTensor<int16_t> arm_compute::test::validation::reference::accumulate_squared	(	const SimpleTensor< uint8_t > &	src,
		uint32_t	shift,
		DataType	output_data_type
	)

accumulate_weighted() [1/2]

SimpleTensor< T2 > accumulate_weighted	(	const SimpleTensor< T1 > &	src,
		float	alpha,
		DataType	output_data_type
	)

Definition at line 58 of file Accumulate.cpp.

{
    ARM_COMPUTE_ERROR_ON_MSG(alpha < 0.f || alpha > 1.f, "Weight (alpha) specified in accumulate_weighted must be within the range [0, 1]");
 
    SimpleTensor<T2> dst{ src.shape(), output_data_type };
 
    library->fill_tensor_uniform(dst, 1, static_cast<T2>(0), static_cast<T2>(std::numeric_limits<T1>::max()));
 
    using intermediate_type = typename common_promoted_signed_type<T1, T2>::intermediate_type;
#if defined(_OPENMP)
    #pragma omp parallel for
#endif /* _OPENMP */
    for(int i = 0; i < src.num_elements(); ++i)
    {
        double val = (1. - static_cast<double>(alpha)) * static_cast<intermediate_type>(dst[i]) + static_cast<double>(alpha) * static_cast<intermediate_type>(src[i]);
        dst[i]     = static_cast<T2>(val);
    }
 
    return dst;
}

References ARM_COMPUTE_ERROR_ON_MSG, arm_compute::test::validation::dst, arm_compute::test::library, and arm_compute::test::validation::src.

accumulate_weighted() [2/2]

template SimpleTensor<uint8_t> arm_compute::test::validation::reference::accumulate_weighted	(	const SimpleTensor< uint8_t > &	src,
		float	alpha,
		DataType	output_data_type
	)

activate_float()

T arm_compute::test::validation::reference::activate_float ( T  x, T  a, T  b, ActivationLayerInfo::ActivationFunction  activation  )

inline

Definition at line 39 of file ActivationLayer.h.

{
    T ret;
 
    switch(activation)
    {
        case ActivationLayerInfo::ActivationFunction::ABS:
            ret = std::abs(x);
            break;
        case ActivationLayerInfo::ActivationFunction::LINEAR:
            ret = a * x + b;
            break;
        case ActivationLayerInfo::ActivationFunction::LOGISTIC:
            ret = static_cast<T>(1) / (static_cast<T>(1) + std::exp(-x));
            break;
        case ActivationLayerInfo::ActivationFunction::RELU:
            ret = std::max<T>(static_cast<T>(0), x);
            break;
        case ActivationLayerInfo::ActivationFunction::BOUNDED_RELU:
            ret = std::min<T>(a, std::max(static_cast<T>(0), x));
            break;
        case ActivationLayerInfo::ActivationFunction::LU_BOUNDED_RELU:
            ret = std::min<T>(a, std::max<T>(b, x));
            break;
        case ActivationLayerInfo::ActivationFunction::LEAKY_RELU:
            ret = (x > 0) ? x : a * x;
            break;
        case ActivationLayerInfo::ActivationFunction::SOFT_RELU:
            ret = std::log(static_cast<T>(1) + std::exp(static_cast<double>(x)));
            break;
        case ActivationLayerInfo::ActivationFunction::ELU:
            ret = (x > 0) ? x : a * (std::exp(x) - static_cast<T>(1));
            break;
        case ActivationLayerInfo::ActivationFunction::SQRT:
            ret = std::sqrt(x);
            break;
        case ActivationLayerInfo::ActivationFunction::SQUARE:
            ret = x * x;
            break;
        case ActivationLayerInfo::ActivationFunction::TANH:
            ret = a * std::tanh(b * x);
            break;
        case ActivationLayerInfo::ActivationFunction::IDENTITY:
            ret = x;
            break;
        case ActivationLayerInfo::ActivationFunction::HARD_SWISH:
            ret = x * ((std::min(std::max(static_cast<T>(x + 3), static_cast<T>(0.0f)), static_cast<T>(6.0f))) * 0.166666667f);
            break;
        case ActivationLayerInfo::ActivationFunction::SWISH:
            ret = static_cast<T>(x) / (static_cast<T>(1) + std::exp(-a*x));
            break;
        case ActivationLayerInfo::ActivationFunction::GELU:
            ret = x * 0.5f * (1 + erf(x / std::sqrt(2.0f)));
            break;
        default:
            ARM_COMPUTE_ERROR("Unsupported activation function");
            break;
    }
 
    return ret;
}

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

activation_layer() [1/4]

template SimpleTensor<float> arm_compute::test::validation::reference::activation_layer	(	const SimpleTensor< float > &	src,
		ActivationLayerInfo	info,
		const QuantizationInfo &	oq_info
	)

activation_layer() [2/4]

template SimpleTensor<half> arm_compute::test::validation::reference::activation_layer	(	const SimpleTensor< half > &	src,
		ActivationLayerInfo	info,
		const QuantizationInfo &	oq_info
	)

activation_layer() [3/4]

template SimpleTensor<int32_t> arm_compute::test::validation::reference::activation_layer	(	const SimpleTensor< int32_t > &	src,
		ActivationLayerInfo	info,
		const QuantizationInfo &	oq_info
	)

activation_layer() [4/4]

SimpleTensor< T > activation_layer	(	const SimpleTensor< T > &	src,
		ActivationLayerInfo	info,
		const QuantizationInfo &	oq_info
	)

Definition at line 38 of file ActivationLayer.cpp.

{
    ARM_COMPUTE_UNUSED(oq_info);
 
    // Create reference
    SimpleTensor<T> dst{ src.shape(), src.data_type(), 1 };
 
    // Compute reference
    const T a(info.a());
    const T b(info.b());
#if defined(_OPENMP)
    #pragma omp parallel for
#endif /* _OPENMP */
    for(int i = 0; i < src.num_elements(); ++i)
    {
        dst[i] = activate_float<T>(src[i], a, b, info.activation());
    }
 
    return dst;
}

References ARM_COMPUTE_UNUSED, arm_compute::test::validation::b, arm_compute::test::validation::dst, arm_compute::test::validation::info, and arm_compute::test::validation::src.

Referenced by batch_normalization_layer(), post_ops(), and arm_compute::test::validation::TEST_CASE().

activation_layer< int16_t >()

SimpleTensor<int16_t> arm_compute::test::validation::reference::activation_layer< int16_t >	(	const SimpleTensor< int16_t > &	src,
		ActivationLayerInfo	info,
		const QuantizationInfo &	oq_info
	)

Definition at line 82 of file ActivationLayer.cpp.

{
    const QuantizationInfo dst_qinfo = oq_info.empty() ? src.quantization_info() : oq_info;
 
    SimpleTensor<float>   src_tmp = convert_from_symmetric(src);
    SimpleTensor<float>   dst_tmp = activation_layer<float>(src_tmp, info);
    SimpleTensor<int16_t> dst     = convert_to_symmetric<int16_t>(dst_tmp, dst_qinfo);
    return dst;
}

References arm_compute::test::validation::convert_from_symmetric(), arm_compute::test::validation::dst, QuantizationInfo::empty(), arm_compute::test::validation::info, and arm_compute::test::validation::src.

activation_layer< int8_t >()

SimpleTensor<int8_t> arm_compute::test::validation::reference::activation_layer< int8_t >	(	const SimpleTensor< int8_t > &	src,
		ActivationLayerInfo	info,
		const QuantizationInfo &	oq_info
	)

Definition at line 71 of file ActivationLayer.cpp.

{
    const QuantizationInfo dst_qinfo = oq_info.empty() ? src.quantization_info() : oq_info;
 
    SimpleTensor<float>  src_tmp = convert_from_asymmetric(src);
    SimpleTensor<float>  dst_tmp = activation_layer<float>(src_tmp, info);
    SimpleTensor<int8_t> dst     = convert_to_asymmetric<int8_t>(dst_tmp, dst_qinfo);
    return dst;
}

References arm_compute::test::validation::convert_from_asymmetric(), arm_compute::test::validation::dst, QuantizationInfo::empty(), arm_compute::test::validation::info, and arm_compute::test::validation::src.

activation_layer< uint8_t >()

SimpleTensor<uint8_t> arm_compute::test::validation::reference::activation_layer< uint8_t >	(	const SimpleTensor< uint8_t > &	src,
		ActivationLayerInfo	info,
		const QuantizationInfo &	oq_info
	)

Definition at line 60 of file ActivationLayer.cpp.

{
    const QuantizationInfo dst_qinfo = oq_info.empty() ? src.quantization_info() : oq_info;
 
    SimpleTensor<float>   src_tmp = convert_from_asymmetric(src);
    SimpleTensor<float>   dst_tmp = activation_layer<float>(src_tmp, info);
    SimpleTensor<uint8_t> dst     = convert_to_asymmetric<uint8_t>(dst_tmp, dst_qinfo);
    return dst;
}

References arm_compute::test::validation::convert_from_asymmetric(), arm_compute::test::validation::dst, QuantizationInfo::empty(), arm_compute::test::validation::info, and arm_compute::test::validation::src.

arithmetic_division() [1/3]

template SimpleTensor<float> arm_compute::test::validation::reference::arithmetic_division	(	const SimpleTensor< float > &	src1,
		const SimpleTensor< float > &	src2,
		DataType	data_type
	)

arithmetic_division() [2/3]

template SimpleTensor<half> arm_compute::test::validation::reference::arithmetic_division	(	const SimpleTensor< half > &	src1,
		const SimpleTensor< half > &	src2,
		DataType	data_type
	)

arithmetic_division() [3/3]

SimpleTensor< T > arithmetic_division	(	const SimpleTensor< T > &	src1,
		const SimpleTensor< T > &	src2,
		DataType	data_type
	)

Definition at line 79 of file ArithmeticDivision.cpp.

{
    SimpleTensor<T> dst(TensorShape::broadcast_shape(src1.shape(), src2.shape()), data_type);
 
    Coordinates id_src1{};
    Coordinates id_src2{};
    Coordinates id_dst{};
 
    BroadcastUnroll<Coordinates::num_max_dimensions>::unroll(src1, src2, dst, id_src1, id_src2, id_dst);
 
    return dst;
}

References TensorShape::broadcast_shape(), arm_compute::test::validation::data_type, arm_compute::test::validation::dst, and SimpleTensor< T >::shape().

arithmetic_operation() [1/13]

template SimpleTensor< float > arithmetic_operation	(	ArithmeticOperation	op,
		const SimpleTensor< float > &	src1,
		const SimpleTensor< float > &	src2,
		DataType	dst_data_type,
		ConvertPolicy	convert_policy
	)

arithmetic_operation() [2/13]

template SimpleTensor< float > arithmetic_operation	(	ArithmeticOperation	op,
		const SimpleTensor< float > &	src1,
		const SimpleTensor< float > &	src2,
		SimpleTensor< float > &	dst,
		ConvertPolicy	convert_policy
	)

arithmetic_operation() [3/13]

template SimpleTensor< half > arithmetic_operation	(	ArithmeticOperation	op,
		const SimpleTensor< half > &	src1,
		const SimpleTensor< half > &	src2,
		DataType	dst_data_type,
		ConvertPolicy	convert_policy
	)

arithmetic_operation() [4/13]

template SimpleTensor< half > arithmetic_operation	(	ArithmeticOperation	op,
		const SimpleTensor< half > &	src1,
		const SimpleTensor< half > &	src2,
		SimpleTensor< half > &	dst,
		ConvertPolicy	convert_policy
	)

arithmetic_operation() [5/13]

template SimpleTensor< int16_t > arithmetic_operation	(	ArithmeticOperation	op,
		const SimpleTensor< int16_t > &	src1,
		const SimpleTensor< int16_t > &	src2,
		DataType	dst_data_type,
		ConvertPolicy	convert_policy
	)

arithmetic_operation() [6/13]

SimpleTensor< int16_t > arithmetic_operation	(	ArithmeticOperation	op,
		const SimpleTensor< int16_t > &	src1,
		const SimpleTensor< int16_t > &	src2,
		SimpleTensor< int16_t > &	dst,
		ConvertPolicy	convert_policy
	)

Definition at line 158 of file ArithmeticOperations.cpp.

{
    Coordinates id_src1{};
    Coordinates id_src2{};
    Coordinates id_dst{};
 
    if(dst.data_type() == DataType::QSYMM16)
    {
        SimpleTensor<float> src1_tmp = convert_from_symmetric<int16_t>(src1);
        SimpleTensor<float> src2_tmp = convert_from_symmetric<int16_t>(src2);
        SimpleTensor<float> dst_tmp(TensorShape::broadcast_shape(src1.shape(), src2.shape()), dst.data_type());
 
        BroadcastUnroll<Coordinates::num_max_dimensions>::unroll(op, src1_tmp, src2_tmp, dst_tmp, convert_policy, id_src1, id_src2, id_dst);
 
        dst = convert_to_symmetric<int16_t>(dst_tmp, dst.quantization_info());
        return dst;
    }
    else
    {
        // DataType::S16
        BroadcastUnroll<Coordinates::num_max_dimensions>::unroll(op, src1, src2, dst, convert_policy, id_src1, id_src2, id_dst);
        return dst;
    }
}

References TensorShape::broadcast_shape(), arm_compute::test::validation::dst, arm_compute::QSYMM16, and SimpleTensor< T >::shape().

arithmetic_operation() [7/13]

template SimpleTensor< int32_t > arithmetic_operation	(	ArithmeticOperation	op,
		const SimpleTensor< int32_t > &	src1,
		const SimpleTensor< int32_t > &	src2,
		DataType	dst_data_type,
		ConvertPolicy	convert_policy
	)

arithmetic_operation() [8/13]

template SimpleTensor< int32_t > arithmetic_operation	(	ArithmeticOperation	op,
		const SimpleTensor< int32_t > &	src1,
		const SimpleTensor< int32_t > &	src2,
		SimpleTensor< int32_t > &	dst,
		ConvertPolicy	convert_policy
	)

arithmetic_operation() [9/13]

template SimpleTensor< int8_t > arithmetic_operation	(	ArithmeticOperation	op,
		const SimpleTensor< int8_t > &	src1,
		const SimpleTensor< int8_t > &	src2,
		DataType	dst_data_type,
		ConvertPolicy	convert_policy
	)

arithmetic_operation() [10/13]

SimpleTensor< int8_t > arithmetic_operation	(	ArithmeticOperation	op,
		const SimpleTensor< int8_t > &	src1,
		const SimpleTensor< int8_t > &	src2,
		SimpleTensor< int8_t > &	dst,
		ConvertPolicy	convert_policy
	)

Definition at line 131 of file ArithmeticOperations.cpp.

{
    Coordinates id_src1{};
    Coordinates id_src2{};
    Coordinates id_dst{};
 
    if(dst.data_type() == DataType::QASYMM8_SIGNED)
    {
        SimpleTensor<float> src1_tmp = convert_from_asymmetric(src1);
        SimpleTensor<float> src2_tmp = convert_from_asymmetric(src2);
        SimpleTensor<float> dst_tmp(TensorShape::broadcast_shape(src1.shape(), src2.shape()), dst.data_type());
 
        BroadcastUnroll<Coordinates::num_max_dimensions>::unroll(op, src1_tmp, src2_tmp, dst_tmp, convert_policy, id_src1, id_src2, id_dst);
 
        dst = convert_to_asymmetric<int8_t>(dst_tmp, dst.quantization_info());
        return dst;
    }
    else
    {
        // DataType::S8
        BroadcastUnroll<Coordinates::num_max_dimensions>::unroll(op, src1, src2, dst, convert_policy, id_src1, id_src2, id_dst);
 
        return dst;
    }
}

References TensorShape::broadcast_shape(), arm_compute::test::validation::convert_from_asymmetric(), arm_compute::test::validation::dst, arm_compute::QASYMM8_SIGNED, and SimpleTensor< T >::shape().

arithmetic_operation() [11/13]

SimpleTensor< T > arithmetic_operation	(	ArithmeticOperation	op,
		const SimpleTensor< T > &	src1,
		const SimpleTensor< T > &	src2,
		DataType	dst_data_type,
		ConvertPolicy	convert_policy
	)

Definition at line 188 of file ArithmeticOperations.cpp.

{
    ARM_COMPUTE_ERROR_ON_MSG(is_data_type_quantized(dst_data_type), "For quantized input data types, the quantized output tensor should be passed directly.");
 
    SimpleTensor<T> dst(TensorShape::broadcast_shape(src1.shape(), src2.shape()), dst_data_type);
    arithmetic_operation<T>(op, src1, src2, dst, convert_policy);
    return dst;
}

References ARM_COMPUTE_ERROR_ON_MSG, TensorShape::broadcast_shape(), arm_compute::test::validation::dst, arm_compute::is_data_type_quantized(), and SimpleTensor< T >::shape().

arithmetic_operation() [12/13]

SimpleTensor< T > arithmetic_operation	(	ArithmeticOperation	op,
		const SimpleTensor< T > &	src1,
		const SimpleTensor< T > &	src2,
		SimpleTensor< T > &	dst,
		ConvertPolicy	convert_policy
	)

Definition at line 92 of file ArithmeticOperations.cpp.

{
    Coordinates id_src1{};
    Coordinates id_src2{};
    Coordinates id_dst{};
 
    BroadcastUnroll<Coordinates::num_max_dimensions>::unroll(op, src1, src2, dst, convert_policy, id_src1, id_src2, id_dst);
 
    return dst;
}

References arm_compute::test::validation::dst.

Referenced by post_ops(), and arm_compute::test::validation::TEST_CASE().

arithmetic_operation() [13/13]

SimpleTensor< uint8_t > arithmetic_operation	(	ArithmeticOperation	op,
		const SimpleTensor< uint8_t > &	src1,
		const SimpleTensor< uint8_t > &	src2,
		SimpleTensor< uint8_t > &	dst,
		ConvertPolicy	convert_policy
	)

Definition at line 104 of file ArithmeticOperations.cpp.

{
    Coordinates id_src1{};
    Coordinates id_src2{};
    Coordinates id_dst{};
 
    if(dst.data_type() == DataType::QASYMM8)
    {
        SimpleTensor<float> src1_tmp = convert_from_asymmetric(src1);
        SimpleTensor<float> src2_tmp = convert_from_asymmetric(src2);
        SimpleTensor<float> dst_tmp(TensorShape::broadcast_shape(src1.shape(), src2.shape()), dst.data_type());
 
        BroadcastUnroll<Coordinates::num_max_dimensions>::unroll(op, src1_tmp, src2_tmp, dst_tmp, convert_policy, id_src1, id_src2, id_dst);
 
        dst = convert_to_asymmetric<uint8_t>(dst_tmp, dst.quantization_info());
        return dst;
    }
    else
    {
        // DataType::U8
        BroadcastUnroll<Coordinates::num_max_dimensions>::unroll(op, src1, src2, dst, convert_policy, id_src1, id_src2, id_dst);
 
        return dst;
    }
}

References TensorShape::broadcast_shape(), arm_compute::test::validation::convert_from_asymmetric(), arm_compute::test::validation::dst, arm_compute::QASYMM8, and SimpleTensor< T >::shape().

batch_normalization_layer() [1/3]

template SimpleTensor<float> arm_compute::test::validation::reference::batch_normalization_layer	(	const SimpleTensor< float > &	src,
		const SimpleTensor< float > &	mean,
		const SimpleTensor< float > &	var,
		const SimpleTensor< float > &	beta,
		const SimpleTensor< float > &	gamma,
		float	epsilon,
		ActivationLayerInfo	act_info
	)

batch_normalization_layer() [2/3]

template SimpleTensor<half> arm_compute::test::validation::reference::batch_normalization_layer	(	const SimpleTensor< half > &	src,
		const SimpleTensor< half > &	mean,
		const SimpleTensor< half > &	var,
		const SimpleTensor< half > &	beta,
		const SimpleTensor< half > &	gamma,
		float	epsilon,
		ActivationLayerInfo	act_info
	)

batch_normalization_layer() [3/3]

SimpleTensor< T > batch_normalization_layer	(	const SimpleTensor< T > &	src,
		const SimpleTensor< T > &	mean,
		const SimpleTensor< T > &	var,
		const SimpleTensor< T > &	beta,
		const SimpleTensor< T > &	gamma,
		float	epsilon,
		ActivationLayerInfo	act_info
	)

Definition at line 40 of file BatchNormalizationLayer.cpp.

{
    SimpleTensor<T> result(src.shape(), src.data_type());
 
    const auto cols       = static_cast<int>(src.shape()[0]);
    const auto rows       = static_cast<int>(src.shape()[1]);
    const auto depth      = static_cast<int>(src.shape()[2]);
    const int  upper_dims = src.shape().total_size() / (cols * rows * depth);
#if defined(_OPENMP)
    #pragma omp parallel for schedule(dynamic, 1) collapse(4)
#endif /* _OPENMP */
    for(int r = 0; r < upper_dims; ++r)
    {
        for(int i = 0; i < depth; ++i)
        {
            for(int k = 0; k < rows; ++k)
            {
                for(int l = 0; l < cols; ++l)
                {
                    const int   pos         = l + k * cols + i * rows * cols + r * cols * rows * depth;
                    const float denominator = sqrt(var[i] + epsilon);
                    const float numerator   = src[pos] - mean[i];
                    const float x_bar       = numerator / denominator;
                    result[pos]             = beta[i] + x_bar * gamma[i];
                }
            }
        }
    }
 
    if(act_info.enabled())
    {
        result = activation_layer(result, act_info);
    }
 
    return result;
}

References arm_compute::test::validation::act_info, activation_layer(), caffe_mnist_image_extractor::cols, arm_compute::quantization::epsilon, arm_compute::test::validation::k, caffe_mnist_image_extractor::rows, and arm_compute::test::validation::src.

batch_to_space() [1/3]

template SimpleTensor<float> arm_compute::test::validation::reference::batch_to_space	(	const SimpleTensor< float > &	src,
		const std::vector< int32_t > &	block_shape,
		const CropInfo &	crop_info,
		const TensorShape &	dst_shape
	)

batch_to_space() [2/3]

template SimpleTensor<half> arm_compute::test::validation::reference::batch_to_space	(	const SimpleTensor< half > &	src,
		const std::vector< int32_t > &	block_shape,
		const CropInfo &	crop_info,
		const TensorShape &	dst_shape
	)

batch_to_space() [3/3]

SimpleTensor< T > batch_to_space	(	const SimpleTensor< T > &	src,
		const std::vector< int32_t > &	block_shape,
		const CropInfo &	crop_info,
		const TensorShape &	dst_shape
	)

Definition at line 40 of file BatchToSpaceLayer.cpp.

{
    ARM_COMPUTE_ERROR_ON(block_shape[0] < 1);
    ARM_COMPUTE_ERROR_ON(block_shape[1] < 1);
    const auto expected_dst_shape = misc::shape_calculator::compute_batch_to_space_shape(DataLayout::NCHW, src.shape(), block_shape[0], block_shape[1], crop_info);
    ARM_COMPUTE_ERROR_ON(arm_compute::detail::have_different_dimensions(expected_dst_shape, dst_shape, 0));
    ARM_COMPUTE_UNUSED(expected_dst_shape);
 
    SimpleTensor<T> result(dst_shape, src.data_type());
    int             out_pos    = 0;
    const auto      width_out  = static_cast<int>(dst_shape[0]);
    const auto      height_out = static_cast<int>(dst_shape[1]);
    const auto      z_out      = static_cast<int>(dst_shape[2]);
    const auto      batch_out  = static_cast<int>(dst_shape[3]);
 
    for(int batch = 0; batch < batch_out; ++batch)
    {
        for(int z = 0; z < z_out; ++z)
        {
            for(int y = 0; y < height_out; ++y)
            {
                for(int x = 0; x < width_out; ++x)
                {
                    const int x_c      = x + crop_info.left;
                    const int y_c      = y + crop_info.top;
                    const int in_batch = batch + ((x_c % block_shape[0]) + (y_c % block_shape[1]) * (block_shape[0])) * dst_shape[3];
                    const int in_x     = x_c / block_shape[0];
                    const int in_y     = y_c / block_shape[1];
                    const int in_pos   = in_x + src.shape()[0] * in_y + z * src.shape()[0] * src.shape()[1] + in_batch * src.shape()[0] * src.shape()[1] * src.shape()[2];
                    result[out_pos]    = src[in_pos];
                    ++out_pos;
                }
            }
        }
    }
 
    return result;
}

References ARM_COMPUTE_ERROR_ON, ARM_COMPUTE_UNUSED, arm_compute::test::validation::batch, arm_compute::misc::shape_calculator::compute_batch_to_space_shape(), arm_compute::test::validation::dst_shape, arm_compute::detail::have_different_dimensions(), Padding2D::left, arm_compute::NCHW, arm_compute::test::validation::src, and Padding2D::top.

bitwise_and() [1/2]

SimpleTensor< T > bitwise_and	(	const SimpleTensor< T > &	src1,
		const SimpleTensor< T > &	src2
	)

Definition at line 35 of file BitwiseAnd.cpp.

{
    SimpleTensor<T> dst(src1.shape(), src1.data_type());
#if defined(_OPENMP)
    #pragma omp parallel for
#endif /* _OPENMP */
    for(int i = 0; i < src1.num_elements(); ++i)
    {
        dst[i] = src1[i] & src2[i];
    }
 
    return dst;
}

References SimpleTensor< T >::data_type(), arm_compute::test::validation::dst, SimpleTensor< T >::num_elements(), and SimpleTensor< T >::shape().

bitwise_and() [2/2]

template SimpleTensor<uint8_t> arm_compute::test::validation::reference::bitwise_and	(	const SimpleTensor< uint8_t > &	src1,
		const SimpleTensor< uint8_t > &	src2
	)

bitwise_not() [1/2]

SimpleTensor< T > bitwise_not

(

const SimpleTensor< T > &

src

)

Definition at line 35 of file BitwiseNot.cpp.

{
    SimpleTensor<T> dst(src.shape(), src.data_type());
#if defined(_OPENMP)
    #pragma omp parallel for
#endif /* _OPENMP */
    for(int i = 0; i < src.num_elements(); ++i)
    {
        dst[i] = ~src[i];
    }
 
    return dst;
}

References arm_compute::test::validation::dst, and arm_compute::test::validation::src.

bitwise_not() [2/2]

template SimpleTensor<uint8_t> arm_compute::test::validation::reference::bitwise_not

(

const SimpleTensor< uint8_t > &

src

)

bitwise_or() [1/2]

SimpleTensor< T > bitwise_or	(	const SimpleTensor< T > &	src1,
		const SimpleTensor< T > &	src2
	)

Definition at line 35 of file BitwiseOr.cpp.

{
    SimpleTensor<T> dst(src1.shape(), src1.data_type());
#if defined(_OPENMP)
    #pragma omp parallel for
#endif /* _OPENMP */
    for(int i = 0; i < src1.num_elements(); ++i)
    {
        dst[i] = src1[i] | src2[i];
    }
 
    return dst;
}

References SimpleTensor< T >::data_type(), arm_compute::test::validation::dst, SimpleTensor< T >::num_elements(), and SimpleTensor< T >::shape().

bitwise_or() [2/2]

template SimpleTensor<uint8_t> arm_compute::test::validation::reference::bitwise_or	(	const SimpleTensor< uint8_t > &	src1,
		const SimpleTensor< uint8_t > &	src2
	)

bitwise_xor() [1/2]

SimpleTensor< T > bitwise_xor	(	const SimpleTensor< T > &	src1,
		const SimpleTensor< T > &	src2
	)

Definition at line 35 of file BitwiseXor.cpp.

{
    SimpleTensor<T> dst(src1.shape(), src1.data_type());
#if defined(_OPENMP)
    #pragma omp parallel for
#endif /* _OPENMP */
    for(int i = 0; i < src1.num_elements(); ++i)
    {
        dst[i] = src1[i] ^ src2[i];
    }
 
    return dst;
}

References SimpleTensor< T >::data_type(), arm_compute::test::validation::dst, SimpleTensor< T >::num_elements(), and SimpleTensor< T >::shape().

bitwise_xor() [2/2]

template SimpleTensor<uint8_t> arm_compute::test::validation::reference::bitwise_xor	(	const SimpleTensor< uint8_t > &	src1,
		const SimpleTensor< uint8_t > &	src2
	)

bounding_box_transform() [1/4]

template SimpleTensor<float> arm_compute::test::validation::reference::bounding_box_transform	(	const SimpleTensor< float > &	boxes,
		const SimpleTensor< float > &	deltas,
		const BoundingBoxTransformInfo &	info
	)

bounding_box_transform() [2/4]

template SimpleTensor<half> arm_compute::test::validation::reference::bounding_box_transform	(	const SimpleTensor< half > &	boxes,
		const SimpleTensor< half > &	deltas,
		const BoundingBoxTransformInfo &	info
	)

bounding_box_transform() [3/4]

SimpleTensor< T > bounding_box_transform	(	const SimpleTensor< T > &	boxes,
		const SimpleTensor< TDeltas > &	deltas,
		const BoundingBoxTransformInfo &	info
	)

Definition at line 40 of file BoundingBoxTransform.cpp.

{
    const DataType  boxes_data_type = boxes.data_type();
    SimpleTensor<T> pred_boxes(deltas.shape(), boxes_data_type);
 
    const size_t   num_classes    = deltas.shape()[0] / 4;
    const size_t   num_boxes      = deltas.shape()[1];
    const TDeltas *deltas_ptr     = deltas.data();
    T             *pred_boxes_ptr = pred_boxes.data();
 
    const int img_h = floor(info.img_height() / info.scale() + 0.5f);
    const int img_w = floor(info.img_width() / info.scale() + 0.5f);
 
    const auto scale_after  = (info.apply_scale() ? T(info.scale()) : T(1));
    const auto scale_before = T(info.scale());
    ARM_COMPUTE_ERROR_ON(scale_before <= 0);
    const auto offset = (info.correct_transform_coords() ? T(1.f) : T(0.f));
 
    const size_t box_fields   = 4;
    const size_t class_fields = 4;
#if defined(_OPENMP)
    #pragma omp parallel for
#endif /* _OPENMP */
    for(size_t i = 0; i < num_boxes; ++i)
    {
        // Extract ROI information
        const size_t start_box = box_fields * i;
        const T      width     = (boxes[start_box + 2] / scale_before) - (boxes[start_box] / scale_before) + T(1.f);
        const T      height    = (boxes[start_box + 3] / scale_before) - (boxes[start_box + 1] / scale_before) + T(1.f);
        const T      ctr_x     = (boxes[start_box] / scale_before) + T(0.5f) * width;
        const T      ctr_y     = (boxes[start_box + 1] / scale_before) + T(0.5f) * height;
 
        for(size_t j = 0; j < num_classes; ++j)
        {
            // Extract deltas
            const size_t  start_delta = i * num_classes * class_fields + class_fields * j;
            const TDeltas dx          = deltas_ptr[start_delta] / TDeltas(info.weights()[0]);
            const TDeltas dy          = deltas_ptr[start_delta + 1] / TDeltas(info.weights()[1]);
            TDeltas       dw          = deltas_ptr[start_delta + 2] / TDeltas(info.weights()[2]);
            TDeltas       dh          = deltas_ptr[start_delta + 3] / TDeltas(info.weights()[3]);
 
            // Clip dw and dh
            dw = std::min(dw, TDeltas(info.bbox_xform_clip()));
            dh = std::min(dh, TDeltas(info.bbox_xform_clip()));
 
            // Determine the predictions
            const T pred_ctr_x = dx * width + ctr_x;
            const T pred_ctr_y = dy * height + ctr_y;
            const T pred_w     = T(std::exp(dw)) * width;
            const T pred_h     = T(std::exp(dh)) * height;
 
            // Store the prediction into the output tensor
            pred_boxes_ptr[start_delta]     = scale_after * utility::clamp<T>(pred_ctr_x - T(0.5f) * pred_w, T(0), T(img_w - 1));
            pred_boxes_ptr[start_delta + 1] = scale_after * utility::clamp<T>(pred_ctr_y - T(0.5f) * pred_h, T(0), T(img_h - 1));
            pred_boxes_ptr[start_delta + 2] = scale_after * utility::clamp<T>(pred_ctr_x + T(0.5f) * pred_w - offset, T(0), T(img_w - 1));
            pred_boxes_ptr[start_delta + 3] = scale_after * utility::clamp<T>(pred_ctr_y + T(0.5f) * pred_h - offset, T(0), T(img_h - 1));
        }
    }
    return pred_boxes;
}

References ARM_COMPUTE_ERROR_ON, SimpleTensor< T >::data(), SimpleTensor< T >::data_type(), arm_compute::test::validation::info, offset(), and SimpleTensor< T >::shape().

bounding_box_transform() [4/4]

SimpleTensor<uint16_t> arm_compute::test::validation::reference::bounding_box_transform	(	const SimpleTensor< uint16_t > &	boxes,
		const SimpleTensor< uint8_t > &	deltas,
		const BoundingBoxTransformInfo &	info
	)

Definition at line 105 of file BoundingBoxTransform.cpp.

{
    SimpleTensor<float>    boxes_tmp      = convert_from_asymmetric(boxes);
    SimpleTensor<float>    deltas_tmp     = convert_from_asymmetric(deltas);
    SimpleTensor<float>    pred_boxes_tmp = bounding_box_transform<float, float>(boxes_tmp, deltas_tmp, info);
    SimpleTensor<uint16_t> pred_boxes     = convert_to_asymmetric<uint16_t>(pred_boxes_tmp, boxes.quantization_info());
    return pred_boxes;
}

References arm_compute::test::validation::convert_from_asymmetric(), arm_compute::test::validation::info, and SimpleTensor< T >::quantization_info().

channel_shuffle() [1/6]

template SimpleTensor<float> arm_compute::test::validation::reference::channel_shuffle	(	const SimpleTensor< float > &	src,
		int	num_groups
	)

channel_shuffle() [2/6]

template SimpleTensor<half> arm_compute::test::validation::reference::channel_shuffle	(	const SimpleTensor< half > &	src,
		int	num_groups
	)

channel_shuffle() [3/6]

SimpleTensor< T > channel_shuffle	(	const SimpleTensor< T > &	src,
		int	num_groups
	)

Definition at line 39 of file ChannelShuffle.cpp.

{
    // Create reference
    SimpleTensor<T> dst{ src.shape(), src.data_type(), src.num_channels(), src.quantization_info() };
 
    const int M                 = src.shape()[0];
    const int N                 = src.shape()[1];
    const int num_channels      = src.shape()[2];
    const int batches           = src.shape()[3];
    const int MxN               = M * N;
    const int channels_in_group = num_channels / num_groups;
 
    const T *src_ref = src.data();
    T       *dst_ref = dst.data();
#if defined(_OPENMP)
    #pragma omp parallel for collapse(2)
#endif /* _OPENMP */
    for(int n = 0; n < batches; ++n)
    {
        for(int g = 0; g < num_groups; ++g)
        {
            // Gather the group g block (of size channels_in_group * MxN) from output channels
            // g + 0 * G, g + 1 * G, g + 2 * G, g + G * (K - 1) etc.
            const T *src_ptr = src_ref + g * channels_in_group * MxN + n * num_channels * MxN;
            T       *dst_ptr = dst_ref + g * MxN + n * num_channels * MxN;
            for(int i = 0; i < channels_in_group; ++i)
            {
                std::copy(src_ptr + i * MxN,
                          src_ptr + (i + 1) * MxN,
                          dst_ptr + i * num_groups * MxN);
            }
        }
    }
 
    return dst;
}

References batches, copy(), arm_compute::test::validation::dst, arm_compute::test::validation::dst_ref, M, N, arm_compute::test::validation::n, arm_compute::test::validation::num_groups, arm_compute::test::validation::src, and arm_compute::test::validation::src_ref.

channel_shuffle() [4/6]

template SimpleTensor<uint16_t> arm_compute::test::validation::reference::channel_shuffle	(	const SimpleTensor< uint16_t > &	src,
		int	num_groups
	)

channel_shuffle() [5/6]

template SimpleTensor<uint32_t> arm_compute::test::validation::reference::channel_shuffle	(	const SimpleTensor< uint32_t > &	src,
		int	num_groups
	)

channel_shuffle() [6/6]

template SimpleTensor<uint8_t> arm_compute::test::validation::reference::channel_shuffle	(	const SimpleTensor< uint8_t > &	src,
		int	num_groups
	)

col2im() [1/4]

template SimpleTensor<float> arm_compute::test::validation::reference::col2im	(	const SimpleTensor< float > &	src,
		const TensorShape &	dst_shape,
		unsigned int	num_groups
	)

col2im() [2/4]

template SimpleTensor<half> arm_compute::test::validation::reference::col2im	(	const SimpleTensor< half > &	src,
		const TensorShape &	dst_shape,
		unsigned int	num_groups
	)

col2im() [3/4]

SimpleTensor< T > col2im	(	const SimpleTensor< T > &	src,
		const TensorShape &	dst_shape,
		unsigned int	num_groups
	)

Definition at line 38 of file Col2Im.cpp.

{
    SimpleTensor<T> dst{ dst_shape, src.data_type(), 1 };
 
    // Compute reference
    const size_t batches    = dst_shape.total_size() / (dst_shape.x() * dst_shape.y() * dst_shape.z());
    const size_t src_width  = src.shape().x();
    const size_t src_height = src.shape().y();
 
    if(num_groups == 1)
    {
        // Batches are on the 3rd dimension of the input tensor
#if defined(_OPENMP)
        #pragma omp parallel for collapse(3)
#endif /* _OPENMP */
        for(size_t b = 0; b < batches; ++b)
        {
            for(size_t x = 0; x < src_width; ++x)
            {
                for(size_t y = 0; y < src_height; ++y)
                {
                    const int dst_idx = y + x * src_height + b * src_height * src_width;
                    dst[dst_idx]      = src[coord2index(src.shape(), Coordinates(x, y, b))];
                }
            }
        }
    }
    else
    {
#if defined(_OPENMP)
        #pragma omp parallel for collapse(4)
#endif /* _OPENMP */
        for(size_t b = 0; b < batches; ++b)
        {
            for(size_t g = 0; g < num_groups; ++g)
            {
                for(size_t x = 0; x < src_width; ++x)
                {
                    for(size_t y = 0; y < src_height; ++y)
                    {
                        const int dst_idx = y + x * src_height + g * src_height * src_width + b * src_height * src_width * num_groups;
                        dst[dst_idx]      = src[coord2index(src.shape(), Coordinates(x, y, g, b))];
                    }
                }
            }
        }
    }
    return dst;
}

References arm_compute::test::validation::b, batches, arm_compute::test::coord2index(), arm_compute::test::validation::dst, arm_compute::test::validation::dst_shape, arm_compute::test::validation::num_groups, arm_compute::test::validation::src, TensorShape::total_size(), Dimensions< T >::x(), Dimensions< T >::y(), and Dimensions< T >::z().

col2im() [4/4]

template SimpleTensor<uint8_t> arm_compute::test::validation::reference::col2im	(	const SimpleTensor< uint8_t > &	src,
		const TensorShape &	dst_shape,
		unsigned int	num_groups
	)

compare() [1/5]

template SimpleTensor<uint8_t> arm_compute::test::validation::reference::compare	(	ComparisonOperation	op,
		const SimpleTensor< float > &	src1,
		const SimpleTensor< float > &	src2
	)

compare() [2/5]

template SimpleTensor<uint8_t> arm_compute::test::validation::reference::compare	(	ComparisonOperation	op,
		const SimpleTensor< half > &	src1,
		const SimpleTensor< half > &	src2
	)

compare() [3/5]

SimpleTensor<uint8_t> arm_compute::test::validation::reference::compare	(	ComparisonOperation	op,
		const SimpleTensor< int8_t > &	src1,
		const SimpleTensor< int8_t > &	src2
	)

Definition at line 146 of file Comparisons.cpp.

{
    SimpleTensor<uint8_t> dst(TensorShape::broadcast_shape(src1.shape(), src2.shape()), DataType::U8);
 
    Coordinates id_src1{};
    Coordinates id_src2{};
    Coordinates id_dst{};
 
    if(src1.data_type() == DataType::QASYMM8_SIGNED)
    {
        SimpleTensor<float> src1_tmp = convert_from_asymmetric(src1);
        SimpleTensor<float> src2_tmp = convert_from_asymmetric(src2);
        BroadcastUnroll<Coordinates::num_max_dimensions>::unroll(op, src1_tmp, src2_tmp, dst, id_src1, id_src2, id_dst);
    }
    else
    {
        // DataType::U8
        BroadcastUnroll<Coordinates::num_max_dimensions>::unroll(op, src1, src2, dst, id_src1, id_src2, id_dst);
    }
    return dst;
}

References TensorShape::broadcast_shape(), arm_compute::test::validation::convert_from_asymmetric(), SimpleTensor< T >::data_type(), arm_compute::test::validation::dst, arm_compute::QASYMM8_SIGNED, SimpleTensor< T >::shape(), and arm_compute::U8.

compare() [4/5]

SimpleTensor< uint8_t > compare	(	ComparisonOperation	op,
		const SimpleTensor< T > &	src1,
		const SimpleTensor< T > &	src2
	)

Definition at line 111 of file Comparisons.cpp.

{
    SimpleTensor<uint8_t> dst(TensorShape::broadcast_shape(src1.shape(), src2.shape()), DataType::U8);
 
    Coordinates id_src1{};
    Coordinates id_src2{};
    Coordinates id_dst{};
    BroadcastUnroll<Coordinates::num_max_dimensions>::unroll(op, src1, src2, dst, id_src1, id_src2, id_dst);
    return dst;
}

References TensorShape::broadcast_shape(), arm_compute::test::validation::dst, SimpleTensor< T >::shape(), and arm_compute::U8.

compare() [5/5]

SimpleTensor<uint8_t> arm_compute::test::validation::reference::compare	(	ComparisonOperation	op,
		const SimpleTensor< uint8_t > &	src1,
		const SimpleTensor< uint8_t > &	src2
	)

Definition at line 123 of file Comparisons.cpp.

{
    SimpleTensor<uint8_t> dst(TensorShape::broadcast_shape(src1.shape(), src2.shape()), DataType::U8);
 
    Coordinates id_src1{};
    Coordinates id_src2{};
    Coordinates id_dst{};
 
    if(src1.data_type() == DataType::QASYMM8)
    {
        SimpleTensor<float> src1_tmp = convert_from_asymmetric(src1);
        SimpleTensor<float> src2_tmp = convert_from_asymmetric(src2);
        BroadcastUnroll<Coordinates::num_max_dimensions>::unroll(op, src1_tmp, src2_tmp, dst, id_src1, id_src2, id_dst);
    }
    else
    {
        // DataType::U8
        BroadcastUnroll<Coordinates::num_max_dimensions>::unroll(op, src1, src2, dst, id_src1, id_src2, id_dst);
    }
    return dst;
}

References TensorShape::broadcast_shape(), arm_compute::test::validation::convert_from_asymmetric(), SimpleTensor< T >::data_type(), arm_compute::test::validation::dst, arm_compute::QASYMM8, SimpleTensor< T >::shape(), and arm_compute::U8.

compute_all_anchors() [1/4]

template SimpleTensor<float> arm_compute::test::validation::reference::compute_all_anchors	(	const SimpleTensor< float > &	anchors,
		const ComputeAnchorsInfo &	info
	)

compute_all_anchors() [2/4]

template SimpleTensor<half> arm_compute::test::validation::reference::compute_all_anchors	(	const SimpleTensor< half > &	anchors,
		const ComputeAnchorsInfo &	info
	)

compute_all_anchors() [3/4]

SimpleTensor<int16_t> arm_compute::test::validation::reference::compute_all_anchors	(	const SimpleTensor< int16_t > &	anchors,
		const ComputeAnchorsInfo &	info
	)

Definition at line 81 of file ComputeAllAnchors.cpp.

{
    SimpleTensor<float>   anchors_tmp     = convert_from_symmetric(anchors);
    SimpleTensor<float>   all_anchors_tmp = compute_all_anchors(anchors_tmp, info);
    SimpleTensor<int16_t> all_anchors     = convert_to_symmetric<int16_t>(all_anchors_tmp, anchors.quantization_info());
    return all_anchors;
}

References compute_all_anchors(), arm_compute::test::validation::convert_from_symmetric(), arm_compute::test::validation::info, and SimpleTensor< T >::quantization_info().

compute_all_anchors() [4/4]

SimpleTensor< T > compute_all_anchors	(	const SimpleTensor< T > &	anchors,
		const ComputeAnchorsInfo &	info
	)

Definition at line 40 of file ComputeAllAnchors.cpp.

{
    const int   num_anchors = anchors.shape()[1];
    const auto  width       = int(info.feat_width());
    const auto  height      = int(info.feat_height());
    const float stride      = 1. / info.spatial_scale();
 
    SimpleTensor<T> all_anchors(TensorShape(4, width * height * num_anchors), anchors.data_type());
    const T        *anchors_ptr     = anchors.data();
    T              *all_anchors_ptr = all_anchors.data();
 
    // Iterate over the input grid and anchors
#if defined(_OPENMP)
    #pragma omp parallel for schedule(dynamic, 1) collapse(3)
#endif /* _OPENMP */
    for(int y = 0; y < height; y++)
    {
        for(int x = 0; x < width; x++)
        {
            for(int a = 0; a < num_anchors; a++)
            {
                const T      shift_x   = T(x) * T(stride);
                const T      shift_y   = T(y) * T(stride);
                const size_t anchor_id = a + x * num_anchors + y * width * num_anchors;
                // x1
                all_anchors_ptr[anchor_id * 4] = anchors_ptr[4 * a] + shift_x;
                // y1
                all_anchors_ptr[anchor_id * 4 + 1] = anchors_ptr[4 * a + 1] + shift_y;
                // x2
                all_anchors_ptr[anchor_id * 4 + 2] = anchors_ptr[4 * a + 2] + shift_x;
                // y2
                all_anchors_ptr[anchor_id * 4 + 3] = anchors_ptr[4 * a + 3] + shift_y;
            }
        }
    }
    return all_anchors;
}

References SimpleTensor< T >::data(), SimpleTensor< T >::data_type(), arm_compute::test::validation::info, and SimpleTensor< T >::shape().

Referenced by compute_all_anchors().

compute_min_max()

void arm_compute::test::validation::reference::compute_min_max	(	const SimpleTensor< T > &	src,
		T &	min,
		T &	max
	)

Definition at line 35 of file MinMaxLocation.cpp.

{
    // Set min and max to first pixel
    min = src[0];
    max = src[0];
 
    ARM_COMPUTE_ERROR_ON(src.num_elements() == 0);
 
    // Look for min and max values
    for(int i = 1; i < src.num_elements(); ++i)
    {
        if(src[i] < min)
        {
            min = src[i];
        }
        if(src[i] > max)
        {
            max = src[i];
        }
    }
}

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

compute_reduction_operation()

SimpleTensor<OT> arm_compute::test::validation::reference::compute_reduction_operation	(	const SimpleTensor< T > &	src,
		const TensorShape &	dst_shape,
		unsigned int	axis,
		ReductionOperation	op,
		DataType	output_type,
		RoundingPolicy	policy
	)

Definition at line 184 of file ReductionOperation.cpp.

{
    // Create reference
    const bool         is_arg_min_max = (op == ReductionOperation::ARG_IDX_MIN || op == ReductionOperation::ARG_IDX_MAX);
    SimpleTensor<OT>   dst{ dst_shape, output_type, 1, src.quantization_info() };
    const unsigned int src_width    = src.shape().x();
    const unsigned int src_height   = src.shape().y();
    const unsigned int src_depth    = src.shape().z();
    const unsigned int src_batch    = src.shape()[3];
    const int          reduce_elems = src.shape()[axis];
 
    switch(axis)
    {
        case 0:
        {
            const unsigned int upper_dims = src.shape().total_size_upper(1);
            for(unsigned int du = 0; du < upper_dims; ++du)
            {
                const T *src_row_ptr = src.data() + du * reduce_elems;
                dst[du]              = is_arg_min_max ?
                                       reduce_operation_arg_min_max<T, OT>(src_row_ptr, reduce_elems, op, 1) :
                                       reduce_operation<T, OT>(src_row_ptr, reduce_elems, op, 1, policy);
            }
        }
        break;
        case 1:
        {
            const unsigned int upper_dims = src.shape().total_size_upper(2);
            for(unsigned int du = 0; du < upper_dims; ++du)
            {
                for(unsigned int x = 0; x < src_width; ++x)
                {
                    const int in_offset   = du * src_height * src_width + x;
                    const int out_offset  = du * src_width + x;
                    const T *src_row_ptr = src.data() + in_offset;
                    dst[out_offset]       = is_arg_min_max ?
                                            reduce_operation_arg_min_max<T, OT>(src_row_ptr, reduce_elems, op, src_width) :
                                            reduce_operation<T, OT>(src_row_ptr, reduce_elems, op, src_width, policy);
                }
            }
        }
        break;
        case 2:
        {
            const unsigned int upper_dims = src.shape().total_size_upper(3);
            for(unsigned int du = 0; du < upper_dims; ++du)
            {
                for(unsigned int x = 0; x < src_width; ++x)
                {
                    for(unsigned int y = 0; y < src_height; ++y)
                    {
                        const int in_offset   = du * src_depth * src_height * src_width + y * src_width + x;
                        const int out_offset  = du * src_width * src_height + y * src_width + x;
                        const T *src_row_ptr = src.data() + in_offset;
                        dst[out_offset]       = is_arg_min_max ?
                                                reduce_operation_arg_min_max<T, OT>(src_row_ptr, reduce_elems, op, src_width * src_height) :
                                                reduce_operation<T, OT>(src_row_ptr, reduce_elems, op, src_width * src_height, policy);
                    }
                }
            }
        }
        break;
        case 3:
        {
            const unsigned int upper_dims = src.shape().total_size_upper(4);
            for(unsigned int du = 0; du < upper_dims; ++du)
            {
                for(unsigned int z = 0; z < src_depth; ++z)
                {
                    for(unsigned int y = 0; y < src_height; ++y)
                    {
                        for(unsigned int x = 0; x < src_width; ++x)
                        {
                            const int in_offset   = du * src_batch * src_depth * src_height * src_width + z * src_width * src_height + y * src_width + x;
                            const int out_offset  = du * src_depth * src_height * src_width + z * src_width * src_height + y * src_width + x;
                            const T *src_row_ptr = src.data() + in_offset;
                            dst[out_offset]       = is_arg_min_max ?
                                                    reduce_operation_arg_min_max<T, OT>(src_row_ptr, reduce_elems, op, src_width * src_height * src_depth) :
                                                    reduce_operation<T, OT>(src_row_ptr, reduce_elems, op, src_width * src_height * src_depth, policy);
                        }
                    }
                }
            }
        }
        break;
        default:
            ARM_COMPUTE_ERROR("Unsupported reduction axis");
    }
 
    return dst;
}

References arm_compute::ARG_IDX_MAX, arm_compute::ARG_IDX_MIN, ARM_COMPUTE_ERROR, arm_compute::test::validation::dst, arm_compute::test::validation::dst_shape, and arm_compute::test::validation::src.

concatenate_layer() [1/5]

template SimpleTensor<float> arm_compute::test::validation::reference::concatenate_layer	(	std::vector< SimpleTensor< float >> &	srcs,
		SimpleTensor< float > &	dst,
		unsigned int	axis
	)

concatenate_layer() [2/5]

template SimpleTensor<half> arm_compute::test::validation::reference::concatenate_layer	(	std::vector< SimpleTensor< half >> &	srcs,
		SimpleTensor< half > &	dst,
		unsigned int	axis
	)

concatenate_layer() [3/5]

template SimpleTensor<int8_t> arm_compute::test::validation::reference::concatenate_layer	(	std::vector< SimpleTensor< int8_t >> &	srcs,
		SimpleTensor< int8_t > &	dst,
		unsigned int	axis
	)

concatenate_layer() [4/5]

SimpleTensor< T > concatenate_layer	(	std::vector< SimpleTensor< T >> &	srcs,
		SimpleTensor< T > &	dst,
		unsigned int	axis
	)

Definition at line 116 of file ConcatenateLayer.cpp.

{
    switch(axis)
    {
        case Window::DimX:
        {
            return widthconcatenate_layer(srcs, dst);
        }
        case Window::DimY:
        {
            for(auto &t : srcs)
            {
                t = reference::permute<T>(t, PermutationVector(1U, 0U));
            }
            dst = reference::permute<T>(dst, PermutationVector(1U, 0U));
            return reference::permute<T>(widthconcatenate_layer(srcs, dst), PermutationVector(1U, 0U));
        }
        case Window::DimZ:
        {
            for(auto &t : srcs)
            {
                t = reference::permute<T>(t, PermutationVector(2U, 1U, 0U));
            }
            dst = reference::permute<T>(dst, PermutationVector(2U, 1U, 0U));
            return reference::permute<T>(widthconcatenate_layer(srcs, dst), PermutationVector(2U, 1U, 0U));
        }
        case 3:
        {
            for(auto &t : srcs)
            {
                t = reference::permute<T>(t, PermutationVector(3U, 2U, 1U, 0U));
            }
            dst      = reference::permute<T>(dst, PermutationVector(3U, 2U, 1U, 0U));
            auto ret = reference::permute<T>(widthconcatenate_layer(srcs, dst), PermutationVector(3U, 2U, 1U, 0U));
            return ret;
        }
        default:
        {
            ARM_COMPUTE_ERROR("Not supported");
            return dst;
        }
    }
}

References ARM_COMPUTE_ERROR, Window::DimX, Window::DimY, Window::DimZ, arm_compute::test::validation::dst, tf_frozen_model_extractor::t, and arm_compute::utils::cast::U.

concatenate_layer() [5/5]

template SimpleTensor<uint8_t> arm_compute::test::validation::reference::concatenate_layer	(	std::vector< SimpleTensor< uint8_t >> &	srcs,
		SimpleTensor< uint8_t > &	dst,
		unsigned int	axis
	)

conv2d_dft() [1/3]

template SimpleTensor<float> arm_compute::test::validation::reference::conv2d_dft	(	const SimpleTensor< float > &	src,
		const SimpleTensor< float > &	w,
		const PadStrideInfo &	conv_info
	)

conv2d_dft() [2/3]

template SimpleTensor<half> arm_compute::test::validation::reference::conv2d_dft	(	const SimpleTensor< half > &	src,
		const SimpleTensor< half > &	w,
		const PadStrideInfo &	conv_info
	)

conv2d_dft() [3/3]

SimpleTensor< T > conv2d_dft	(	const SimpleTensor< T > &	src,
		const SimpleTensor< T > &	w,
		const PadStrideInfo &	conv_info
	)

Performs and DFT based convolution on a real input.

Parameters

[in]	src	Source tensor.
[in]	w	Weights tensor.
[in]	conv_info	Convolution related metadata.

Returns

The output tensor.

Definition at line 396 of file DFT.cpp.

{
    // Pad input to full padding
    const PaddingList padding_in = { { 0, w.shape()[0] - 1 }, { 0, w.shape()[1] - 1 } };
    auto              padded_src = pad_layer(src, padding_in);
 
    // Flip weights
    std::vector<uint32_t>  axis_v = { 0, 1 };
    SimpleTensor<uint32_t> axis{ TensorShape(2U), DataType::U32 };
    std::copy(axis_v.begin(), axis_v.begin() + axis.shape().x(), axis.data());
    auto flipped_w = reverse(w, axis);
 
    // Pad weights to have the same size as input
    const PaddingList paddings_w = { { 0, src.shape()[0] - 1 }, { 0, src.shape()[1] - 1 } };
    auto              padded_w   = pad_layer(flipped_w, paddings_w);
 
    // Transform input and weights to frequency domain
    auto Fsrc = rdft_2d(padded_src);
    auto Fw   = rdft_2d(padded_w);
 
    // Perform dot product
    auto Fdst = complex_mul_and_reduce(Fsrc, Fw);
 
    // Transform output back to frequency domain
    auto conv_res = ridft_2d(Fdst);
 
    // Slice output
    const int start_left = w.shape().x() - conv_info.pad_left() - 1;
    const int start_top  = w.shape().y() - conv_info.pad_top() - 1;
    const int end_right  = conv_res.shape().x() - (w.shape().x() - conv_info.pad_right() - 1);
    const int end_botton = conv_res.shape().y() - (w.shape().y() - conv_info.pad_bottom() - 1);
    return slice(conv_res, Coordinates(start_left, start_top), Coordinates(end_right, end_botton));
}

References arm_compute::test::validation::conv_info, copy(), pad_layer(), rdft_2d(), reverse(), ridft_2d(), slice(), arm_compute::test::validation::src, arm_compute::utils::cast::U, arm_compute::U32, and arm_compute::test::validation::w.

conv3d() [1/5]

template SimpleTensor<float> arm_compute::test::validation::reference::conv3d	(	const SimpleTensor< float > &	src,
		const SimpleTensor< float > &	weights,
		const SimpleTensor< float > &	bias,
		SimpleTensor< float > &	dst,
		const Conv3dInfo &	conv3d_info
	)

conv3d() [2/5]

template SimpleTensor<half> arm_compute::test::validation::reference::conv3d	(	const SimpleTensor< half > &	src,
		const SimpleTensor< half > &	weights,
		const SimpleTensor< half > &	bias,
		SimpleTensor< half > &	dst,
		const Conv3dInfo &	conv3d_info
	)

conv3d() [3/5]

template SimpleTensor<int8_t> arm_compute::test::validation::reference::conv3d	(	const SimpleTensor< int8_t > &	src,
		const SimpleTensor< int8_t > &	weights,
		const SimpleTensor< int32_t > &	bias,
		SimpleTensor< int8_t > &	dst,
		const Conv3dInfo &	conv3d_info
	)

conv3d() [4/5]

SimpleTensor< T > conv3d	(	const SimpleTensor< T > &	src,
		const SimpleTensor< T > &	weights,
		const SimpleTensor< TB > &	bias,
		SimpleTensor< T > &	dst,
		const Conv3dInfo &	conv3d_info
	)

Definition at line 193 of file Conv3D.cpp.

{
    // Compute reference
    const unsigned int batch_size     = src.shape()[batch_dim];
    const unsigned int dst_width      = dst.shape()[width_dim];
    const unsigned int dst_height     = dst.shape()[height_dim];
    const unsigned int dst_depth      = dst.shape()[depth_dim];
    const unsigned int src_channels   = src.shape()[channel_dim];
    const unsigned int weights_out_ch = weights.shape()[weights_CHout_dim];
    const unsigned int dst_channels   = dst.shape()[channel_dim];
    const size_t       pad_left       = conv3d_info.padding.left;
    const size_t       pad_top        = conv3d_info.padding.top;
    const size_t       pad_front      = conv3d_info.padding.front;
    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();
 
    const TensorShape dst_shape = arm_compute::misc::shape_calculator::compute_conv3d_shape(src.shape(), weights.shape(), conv3d_info);
 
    ARM_COMPUTE_UNUSED(src_channels, weights_out_ch, dst_channels, dst_shape, weights_CHin_dim);
    // Number of batches of source and destination tensors must match.
    ARM_COMPUTE_ERROR_ON(src.shape()[batch_dim] != dst.shape()[batch_dim]);
    // Input channels in the source and weights must match.
    ARM_COMPUTE_ERROR_ON(src_channels != weights.shape()[weights_CHin_dim]);
    // Weight channels in the destination and weights must match.
    ARM_COMPUTE_ERROR_ON(weights_out_ch != dst_channels);
    // Bias must match the number of destination channels.
    ARM_COMPUTE_ERROR_ON(bias.shape()[0] != dst_channels);
    // Compare given dst tensor shape with expected shape.
    ARM_COMPUTE_ERROR_ON(dst.shape() != dst_shape);
 
    for(unsigned int batch = 0; batch < batch_size; ++batch)
    {
        for(unsigned int z_out = 0; z_out < dst_depth; ++z_out)
        {
            const int z_start = (z_out * stride_z) - pad_front;
            for(unsigned int y_out = 0; y_out < dst_height; ++y_out)
            {
                const int y_start = (y_out * stride_y) - pad_top;
                for(unsigned int x_out = 0; x_out < dst_width; ++x_out)
                {
                    const int x_start = (x_out * stride_x) - pad_left;
                    for(unsigned int ch_out = 0; ch_out < dst_channels; ++ch_out)
                    {
                        T *out_ptr = dst.data();
 
                        const int out_offset = coord2index(dst.shape(), Coordinates{ ch_out, x_out, y_out, z_out, batch });
                        out_ptr[out_offset]  = calculate_conv3d<T, TB>(src, weights, bias, conv3d_info.dilation, batch, z_start, y_start, x_start, ch_out, dst.quantization_info().uniform());
                    }
                }
            }
        }
    }
    return dst;
}

References ARM_COMPUTE_ERROR_ON, ARM_COMPUTE_UNUSED, arm_compute::test::validation::batch, batch_dim, bias, channel_dim, arm_compute::misc::shape_calculator::compute_conv3d_shape(), arm_compute::test::coord2index(), depth_dim, Conv3dInfo::dilation, arm_compute::test::validation::dst, arm_compute::test::validation::dst_shape, Padding3D::front, height_dim, Padding3D::left, Conv3dInfo::padding, SimpleTensor< T >::shape(), arm_compute::test::validation::src, Conv3dInfo::stride, Padding3D::top, weights_CHin_dim, weights_CHout_dim, width_dim, Size3D::x(), x_start, Size3D::y(), and Size3D::z().

conv3d() [5/5]

template SimpleTensor<uint8_t> arm_compute::test::validation::reference::conv3d	(	const SimpleTensor< uint8_t > &	src,
		const SimpleTensor< uint8_t > &	weights,
		const SimpleTensor< int32_t > &	bias,
		SimpleTensor< uint8_t > &	dst,
		const Conv3dInfo &	conv3d_info
	)

convert_fully_connected_weights() [1/4]

template SimpleTensor<float> arm_compute::test::validation::reference::convert_fully_connected_weights	(	const SimpleTensor< float > &	src,
		const TensorShape &	original_input_shape,
		const DataLayout	training_data_layout
	)

convert_fully_connected_weights() [2/4]

template SimpleTensor<half> arm_compute::test::validation::reference::convert_fully_connected_weights	(	const SimpleTensor< half > &	src,
		const TensorShape &	original_input_shape,
		const DataLayout	training_data_layout
	)

convert_fully_connected_weights() [3/4]

SimpleTensor< T > convert_fully_connected_weights	(	const SimpleTensor< T > &	src,
		const TensorShape &	original_input_shape,
		const DataLayout	training_data_layout
	)

Definition at line 35 of file ConvertFullyConnectedWeights.cpp.

{
    SimpleTensor<T> dst(src.shape(), src.data_type());
 
    const DataLayout original_input_data_layout = (training_data_layout == DataLayout::NCHW) ? DataLayout::NHWC : DataLayout::NCHW;
 
    const int width_idx   = get_data_layout_dimension_index(original_input_data_layout, DataLayoutDimension::WIDTH);
    const int height_idx  = get_data_layout_dimension_index(original_input_data_layout, DataLayoutDimension::HEIGHT);
    const int channel_idx = get_data_layout_dimension_index(original_input_data_layout, DataLayoutDimension::CHANNEL);
 
    const bool         is_nchw_to_nhwc           = training_data_layout == DataLayout::NCHW;
    const unsigned int num_elems_per_input_plane = original_input_shape[width_idx] * original_input_shape[height_idx];
    const unsigned int num_channels              = original_input_shape[channel_idx];
    const unsigned int factor_1                  = is_nchw_to_nhwc ? num_elems_per_input_plane : num_channels;
    const unsigned int factor_2                  = is_nchw_to_nhwc ? num_channels : num_elems_per_input_plane;
 
    const uint32_t num_elements = src.num_elements();
#if defined(_OPENMP)
    #pragma omp parallel for
#endif /* _OPENMP */
    for(uint32_t i = 0; i < num_elements; ++i)
    {
        const Coordinates coords_in = index2coords(src.shape(), i);
        const Coordinates coords_out(coords_in.x(), coords_in.y() % factor_1 * factor_2 + coords_in.y() / factor_1);
 
        dst[coords2index(dst.shape(), coords_out)] = src[i];
    }
 
    return dst;
}

References arm_compute::CHANNEL, arm_compute::coords2index(), arm_compute::test::validation::dst, arm_compute::get_data_layout_dimension_index(), arm_compute::HEIGHT, arm_compute::index2coords(), arm_compute::NCHW, arm_compute::NHWC, arm_compute::test::validation::src, arm_compute::WIDTH, Dimensions< T >::x(), and Dimensions< T >::y().

convert_fully_connected_weights() [4/4]

template SimpleTensor<uint8_t> arm_compute::test::validation::reference::convert_fully_connected_weights	(	const SimpleTensor< uint8_t > &	src,
		const TensorShape &	original_input_shape,
		const DataLayout	training_data_layout
	)

convolution_layer() [1/6]

template SimpleTensor<float> arm_compute::test::validation::reference::convolution_layer	(	const SimpleTensor< float > &	src,
		const SimpleTensor< float > &	weights,
		const SimpleTensor< float > &	bias,
		const TensorShape &	output_shape,
		const PadStrideInfo &	info,
		const Size2D &	dilation,
		unsigned int	num_groups,
		QuantizationInfo	out_quant_info
	)

convolution_layer() [2/6]

template SimpleTensor<half> arm_compute::test::validation::reference::convolution_layer	(	const SimpleTensor< half > &	src,
		const SimpleTensor< half > &	weights,
		const SimpleTensor< half > &	bias,
		const TensorShape &	output_shape,
		const PadStrideInfo &	info,
		const Size2D &	dilation,
		unsigned int	num_groups,
		QuantizationInfo	out_quant_info
	)

convolution_layer() [3/6]

template SimpleTensor<int8_t> arm_compute::test::validation::reference::convolution_layer	(	const SimpleTensor< int8_t > &	src,
		const SimpleTensor< int8_t > &	weights,
		const SimpleTensor< int32_t > &	bias,
		const TensorShape &	output_shape,
		const PadStrideInfo &	info,
		const Size2D &	dilation,
		unsigned int	num_groups,
		QuantizationInfo	out_quant_info
	)

convolution_layer() [4/6]

SimpleTensor< T > convolution_layer	(	const SimpleTensor< T > &	src,
		const SimpleTensor< TW > &	weights,
		const SimpleTensor< TB > &	bias,
		const TensorShape &	output_shape,
		const PadStrideInfo &	info,
		const Size2D &	dilation,
		unsigned int	num_groups,
		QuantizationInfo	out_quant_info
	)

Definition at line 111 of file ConvolutionLayer.cpp.

{
    // if no explicit quantization has been set you the same as src
    if(out_quant_info == QuantizationInfo())
    {
        out_quant_info = src.quantization_info();
    }
    // Create reference
    SimpleTensor<T> dst{ output_shape, src.data_type(), 1, out_quant_info };
 
    return convolution_layer_nchw(src, weights, bias, dst, info, dilation, num_groups);
}

References bias, convolution_layer_nchw(), arm_compute::test::validation::dst, arm_compute::test::validation::info, arm_compute::test::validation::num_groups, arm_compute::test::validation::output_shape, and arm_compute::test::validation::src.

Referenced by deconvolution_layer(), and arm_compute::test::validation::TEST_CASE().

convolution_layer() [5/6]

template SimpleTensor<uint8_t> arm_compute::test::validation::reference::convolution_layer	(	const SimpleTensor< uint8_t > &	src,
		const SimpleTensor< int8_t > &	weights,
		const SimpleTensor< int32_t > &	bias,
		const TensorShape &	output_shape,
		const PadStrideInfo &	info,
		const Size2D &	dilation,
		unsigned int	num_groups,
		QuantizationInfo	out_quant_info
	)

convolution_layer() [6/6]

template SimpleTensor<uint8_t> arm_compute::test::validation::reference::convolution_layer	(	const SimpleTensor< uint8_t > &	src,
		const SimpleTensor< uint8_t > &	weights,
		const SimpleTensor< int32_t > &	bias,
		const TensorShape &	output_shape,
		const PadStrideInfo &	info,
		const Size2D &	dilation,
		unsigned int	num_groups,
		QuantizationInfo	out_quant_info
	)

convolution_layer_nchw()

SimpleTensor<T> arm_compute::test::validation::reference::convolution_layer_nchw	(	const SimpleTensor< T > &	src,
		const SimpleTensor< TW > &	weights,
		const SimpleTensor< TB > &	bias,
		SimpleTensor< T > &	dst,
		const PadStrideInfo &	info,
		const Size2D &	dilation,
		unsigned int	num_groups
	)

Definition at line 45 of file ConvolutionLayer.cpp.

{
    ARM_COMPUTE_ERROR_ON((src.shape()[2] / num_groups) != weights.shape()[2]);
 
    // Compute reference
    const int width_in       = src.shape().x();
    const int height_in      = src.shape().y();
    const int depth_in       = src.shape().z();
    const int width_out      = dst.shape().x();
    const int height_out     = dst.shape().y();
    const int depth_out      = dst.shape().z();
    const int width_weights  = weights.shape().x();
    const int height_weights = weights.shape().y();
    const int depth_weights  = weights.shape().z();
    const int pad_left       = info.pad_left();
    const int pad_top        = info.pad_top();
    const int stride_xi      = info.stride().first;
    const int stride_yi      = info.stride().second;
 
    auto output_wh = scaled_dimensions(width_in, height_in, width_weights, height_weights, info, dilation);
 
    const int start_xi    = (dilation.x() * (width_weights - 1) + 1) / 2 - pad_left;
    const int start_yi    = (dilation.y() * (height_weights - 1) + 1) / 2 - pad_top;
    const int end_xi      = output_wh.first * stride_xi;
    const int end_yi      = output_wh.second * stride_yi;
    const int num_batches = src.shape().total_size() / (width_in * height_in * depth_in);
 
#if defined(_OPENMP) && !( defined(__arm__) && defined(__ANDROID__))
    #pragma omp parallel for collapse(5)
#endif /* _OPENMP */
    for(int r = 0; r < num_batches; ++r)
    {
        for(int yi = start_yi; yi < start_yi + end_yi; yi += stride_yi)
        {
            for(int xi = start_xi; xi < start_xi + end_xi; xi += stride_xi)
            {
                for(int group = 0; group < static_cast<int>(num_groups); ++group)
                {
                    for(int ofm = 0; ofm < static_cast<int>(depth_out / num_groups); ++ofm)
                    {
                        // Compute input and output offsets
                        const int offset_in  = r * width_in * height_in * depth_in + (group * (depth_in / num_groups) * width_in * height_in);
                        const int xo         = (xi - start_xi) / stride_xi;
                        const int yo         = (yi - start_yi) / stride_yi;
                        const int offset_out = xo + yo * width_out + ((ofm + group * (depth_out / num_groups)) * width_out * height_out) + (r * width_out * height_out * depth_out);
                        const int offset_w   = (ofm + group * (depth_out / num_groups)) * width_weights * height_weights * depth_weights;
                        const int offset_b   = (ofm + group * (depth_out / num_groups));
 
                        ARM_COMPUTE_ASSERT(xo < width_out);
                        ARM_COMPUTE_ASSERT(yo < height_out);
 
                        // Compute 3D convolution
                        convolution_3d::detail::convolution3d(src, weights, bias, dst,
                                                              offset_in, offset_w, offset_b, offset_out,
                                                              xi, yi,
                                                              width_in, height_in, (depth_in / num_groups),
                                                              width_weights, height_weights, dilation.x(), dilation.y(), ofm);
                    }
                }
            }
        }
    }
    return dst;
}

References ARM_COMPUTE_ASSERT, ARM_COMPUTE_ERROR_ON, bias, arm_compute::test::convolution_3d::detail::convolution3d(), arm_compute::test::validation::dst, arm_compute::test::validation::info, arm_compute::test::validation::num_groups, arm_compute::test::validation::output_wh, arm_compute::scaled_dimensions(), SimpleTensor< T >::shape(), arm_compute::test::validation::src, Size2D::x(), and Size2D::y().

Referenced by convolution_layer().

copy() [1/9]

template SimpleTensor<float> arm_compute::test::validation::reference::copy	(	const SimpleTensor< float > &	src,
		const TensorShape &	output_shape
	)

copy() [2/9]

template SimpleTensor<half> arm_compute::test::validation::reference::copy	(	const SimpleTensor< half > &	src,
		const TensorShape &	output_shape
	)

copy() [3/9]

template SimpleTensor<int16_t> arm_compute::test::validation::reference::copy	(	const SimpleTensor< int16_t > &	src,
		const TensorShape &	output_shape
	)

copy() [4/9]

template SimpleTensor<int32_t> arm_compute::test::validation::reference::copy	(	const SimpleTensor< int32_t > &	src,
		const TensorShape &	output_shape
	)

copy() [5/9]

template SimpleTensor<int8_t> arm_compute::test::validation::reference::copy	(	const SimpleTensor< int8_t > &	src,
		const TensorShape &	output_shape
	)

copy() [6/9]

SimpleTensor< T > copy	(	const SimpleTensor< T > &	src,
		const TensorShape &	output_shape
	)

Definition at line 37 of file Copy.cpp.

{
    ARM_COMPUTE_ERROR_ON_MISMATCHING_DIMENSIONS(src.shape(), output_shape);
 
    SimpleTensor<T> dst(output_shape, src.data_type());
    std::copy_n(src.data(), src.num_elements(), dst.data());
    return dst;
}

References ARM_COMPUTE_ERROR_ON_MISMATCHING_DIMENSIONS, arm_compute::test::validation::dst, arm_compute::test::validation::output_shape, and arm_compute::test::validation::src.

Referenced by channel_shuffle(), Dimensions< size_t >::collapse(), TensorShape::collapsed_from(), conv2d_dft(), depthconcatenate_layer(), flatten_layer(), gemm_reshape_lhs_matrix(), gemm_reshape_rhs_matrix(), arm_compute::test::validation::get_tile(), arm_compute::utils::memory::make_deep_unique(), Dimensions< size_t >::remove(), and TensorShape::remove_dimension().

copy() [7/9]

template SimpleTensor<uint16_t> arm_compute::test::validation::reference::copy	(	const SimpleTensor< uint16_t > &	src,
		const TensorShape &	output_shape
	)

copy() [8/9]

template SimpleTensor<uint32_t> arm_compute::test::validation::reference::copy	(	const SimpleTensor< uint32_t > &	src,
		const TensorShape &	output_shape
	)

copy() [9/9]

template SimpleTensor<uint8_t> arm_compute::test::validation::reference::copy	(	const SimpleTensor< uint8_t > &	src,
		const TensorShape &	output_shape
	)

crop_and_resize() [1/8]

template SimpleTensor<float> arm_compute::test::validation::reference::crop_and_resize	(	const SimpleTensor< float > &	src,
		const SimpleTensor< float > &	boxes,
		SimpleTensor< int32_t >	box_ind,
		Coordinates2D	crop_size,
		InterpolationPolicy	method,
		float	extrapolation_value
	)

crop_and_resize() [2/8]

template SimpleTensor<float> arm_compute::test::validation::reference::crop_and_resize	(	const SimpleTensor< half > &	src,
		const SimpleTensor< float > &	boxes,
		SimpleTensor< int32_t >	box_ind,
		Coordinates2D	crop_size,
		InterpolationPolicy	method,
		float	extrapolation_value
	)

crop_and_resize() [3/8]

template SimpleTensor<float> arm_compute::test::validation::reference::crop_and_resize	(	const SimpleTensor< int16_t > &	src,
		const SimpleTensor< float > &	boxes,
		SimpleTensor< int32_t >	box_ind,
		Coordinates2D	crop_size,
		InterpolationPolicy	method,
		float	extrapolation_value
	)

crop_and_resize() [4/8]

template SimpleTensor<float> arm_compute::test::validation::reference::crop_and_resize	(	const SimpleTensor< int32_t > &	src,
		const SimpleTensor< float > &	boxes,
		SimpleTensor< int32_t >	box_ind,
		Coordinates2D	crop_size,
		InterpolationPolicy	method,
		float	extrapolation_value
	)

crop_and_resize() [5/8]

SimpleTensor< float > crop_and_resize	(	const SimpleTensor< T > &	src,
		const SimpleTensor< float > &	boxes,
		SimpleTensor< int32_t >	box_ind,
		Coordinates2D	crop_size,
		InterpolationPolicy	method,
		float	extrapolation_value
	)

Definition at line 160 of file CropResize.cpp.

{
    ARM_COMPUTE_ERROR_ON(src.shape().num_dimensions() > 4);
    ARM_COMPUTE_ERROR_ON(src.data_layout() != DataLayout::NHWC);
 
    const TensorShape   out_shape(src.shape()[0], crop_size.x, crop_size.y, boxes.shape()[1]);
    SimpleTensor<float> out{ out_shape, DataType::F32, 1, QuantizationInfo(), DataLayout::NHWC };
 
    const TensorShape scaled_image_shape(src.shape()[0], crop_size.x, crop_size.y);
 
    for(uint32_t i = 0; i < boxes.shape()[1]; ++i)
    {
        Coordinates start = Coordinates(std::floor((*reinterpret_cast<const float *>(boxes(Coordinates(1, i)))) * (src.shape()[1] - 1) + 0.5f),
                                        std::floor((*reinterpret_cast<const float *>(boxes(Coordinates(0, i)))) * (src.shape()[2] - 1) + 0.5f));
        Coordinates end = Coordinates(std::floor((*reinterpret_cast<const float *>(boxes(Coordinates(3, i)))) * (src.shape()[1] - 1) + 0.5f),
                                      std::floor((*reinterpret_cast<const float *>(boxes(Coordinates(2, i)))) * (src.shape()[2] - 1) + 0.5f));
        SimpleTensor<float> cropped = crop_image(src, start, end, box_ind[i], extrapolation_value);
        SimpleTensor<float> scaled  = scale_image(cropped, scaled_image_shape, method, extrapolation_value);
        std::copy_n(reinterpret_cast<float *>(scaled.data()), scaled.num_elements(), reinterpret_cast<float *>(out(Coordinates(0, 0, 0, i))));
    }
    return out;
}

References ARM_COMPUTE_ERROR_ON, SimpleTensor< T >::data(), arm_compute::mlgo::parser::end(), arm_compute::F32, arm_compute::NHWC, SimpleTensor< T >::num_elements(), SimpleTensor< T >::shape(), arm_compute::test::validation::src, Coordinates2D::x, and Coordinates2D::y.

crop_and_resize() [6/8]

template SimpleTensor<float> arm_compute::test::validation::reference::crop_and_resize	(	const SimpleTensor< uint16_t > &	src,
		const SimpleTensor< float > &	boxes,
		SimpleTensor< int32_t >	box_ind,
		Coordinates2D	crop_size,
		InterpolationPolicy	method,
		float	extrapolation_value
	)

crop_and_resize() [7/8]

template SimpleTensor<float> arm_compute::test::validation::reference::crop_and_resize	(	const SimpleTensor< uint32_t > &	src,
		const SimpleTensor< float > &	boxes,
		SimpleTensor< int32_t >	box_ind,
		Coordinates2D	crop_size,
		InterpolationPolicy	method,
		float	extrapolation_value
	)

crop_and_resize() [8/8]

template SimpleTensor<float> arm_compute::test::validation::reference::crop_and_resize	(	const SimpleTensor< uint8_t > &	src,
		const SimpleTensor< float > &	boxes,
		SimpleTensor< int32_t >	box_ind,
		Coordinates2D	crop_size,
		InterpolationPolicy	method,
		float	extrapolation_value
	)

deconvolution_layer() [1/6]

template SimpleTensor<float> arm_compute::test::validation::reference::deconvolution_layer	(	const SimpleTensor< float > &	src,
		const SimpleTensor< float > &	weights,
		const SimpleTensor< float > &	bias,
		const TensorShape &	output_shape,
		const PadStrideInfo &	info,
		QuantizationInfo	out_quant_info
	)

deconvolution_layer() [2/6]

template SimpleTensor<half> arm_compute::test::validation::reference::deconvolution_layer	(	const SimpleTensor< half > &	src,
		const SimpleTensor< half > &	weights,
		const SimpleTensor< half > &	bias,
		const TensorShape &	output_shape,
		const PadStrideInfo &	info,
		QuantizationInfo	out_quant_info
	)

deconvolution_layer() [3/6]

template SimpleTensor<int8_t> arm_compute::test::validation::reference::deconvolution_layer	(	const SimpleTensor< int8_t > &	src,
		const SimpleTensor< int8_t > &	weights,
		const SimpleTensor< int32_t > &	bias,
		const TensorShape &	output_shape,
		const PadStrideInfo &	info,
		QuantizationInfo	out_quant_info
	)

deconvolution_layer() [4/6]

SimpleTensor< T > deconvolution_layer	(	const SimpleTensor< T > &	src,
		const SimpleTensor< TW > &	weights,
		const SimpleTensor< TB > &	bias,
		const TensorShape &	output_shape,
		const PadStrideInfo &	info,
		QuantizationInfo	out_qinfo = QuantizationInfo()
	)

Deconvolution reference implementation.

src Input tensor. 3 lower dimensions represent a single input, and an optional 4th dimension for batch of inputs. Data types supported: QASYMM8/QASYMM8_SIGNED/F32/F16. weights The 4d weights with dimensions [width, height, OFM, IFM]. Data type supported: Same as input, also could be QSYMM8_PER_CHANNEL if input is QASYMM8/QASYMM8_SIGNED. bias Optional, ignored if NULL. The biases have one dimension. Data type supported: Same as input, except for input of QASYMM8/QASYMM8_SIGNED types where biases should be of S32 type output_shape Output tensor shape. The output has the same number of dimensions as the input. info Contains padding and policies to be used in the deconvolution, this is decribed in PadStrideInfo. a The number of zeros added to right and top edges of the input.

Definition at line 37 of file DeconvolutionLayer.cpp.

{
    // Create reference
    const unsigned int pad_left           = info.pad_left();
    const unsigned int pad_right          = info.pad_right();
    const unsigned int pad_top            = info.pad_top();
    const unsigned int pad_bottom         = info.pad_bottom();
    const int          stride_x           = info.stride().first;
    const int          stride_y           = info.stride().second;
    const int          weights_width      = weights.shape().x();
    const int          weights_height     = weights.shape().y();
    const int          weights_upper_dims = weights.shape().total_size() / (weights_width * weights_height);
 
    ARM_COMPUTE_ERROR_ON(pad_left > (weights.shape().x() - 1));
    ARM_COMPUTE_ERROR_ON(pad_right > (weights.shape().x() - 1));
    ARM_COMPUTE_ERROR_ON(pad_top > (weights.shape().y() - 1));
    ARM_COMPUTE_ERROR_ON(pad_bottom > (weights.shape().y() - 1));
 
    // Find the upsampled dimensions
    unsigned int out_x = (src.shape().x() - 1) * stride_x + 1;
    unsigned int out_y = (src.shape().y() - 1) * stride_y + 1;
 
    // Find the padding needed for the convolution with stride 1 in order to match output shape
    unsigned int deconv_pad_x = output_shape.x() - (out_x - weights_width + 1);
    unsigned int deconv_pad_y = output_shape.y() - (out_y - weights_height + 1);
    out_x += deconv_pad_x;
    out_y += deconv_pad_y;
 
    unsigned int deconv_pad_left  = pad_right > pad_left ? pad_right - pad_left : 0;
    unsigned int deconv_pad_right = pad_left > pad_right ? pad_left - pad_right : 0;
    deconv_pad_x -= deconv_pad_left + deconv_pad_right;
    ARM_COMPUTE_ERROR_ON((deconv_pad_x % 2) != 0);
    deconv_pad_left += deconv_pad_x / 2;
    deconv_pad_right += deconv_pad_x / 2;
 
    unsigned int deconv_pad_top    = pad_bottom > pad_top ? pad_bottom - pad_top : 0;
    unsigned int deconv_pad_bottom = pad_top > pad_bottom ? pad_top - pad_bottom : 0;
    deconv_pad_y -= deconv_pad_top + deconv_pad_bottom;
    ARM_COMPUTE_ERROR_ON((deconv_pad_y % 2) != 0);
    deconv_pad_top += deconv_pad_y / 2;
    deconv_pad_bottom += deconv_pad_y / 2;
 
    TensorShape scaled_shape = src.shape();
    scaled_shape.set(0, out_x);
    scaled_shape.set(1, out_y);
    SimpleTensor<T> scaled{ scaled_shape, src.data_type(), 1, src.quantization_info() };
 
    const int width_in      = src.shape().x();
    const int height_in     = src.shape().y();
    const int width_scaled  = scaled.shape().x();
    const int height_scaled = scaled.shape().y();
    const int num_2d_slices = src.shape().total_size() / (width_in * height_in);
 
    if(src.data_type() == DataType::QASYMM8 || src.data_type() == DataType::QASYMM8_SIGNED)
    {
        const auto quantized_zero = static_cast<T>(src.quantization_info().uniform().offset);
        std::fill_n(scaled.data(), scaled.num_elements(), quantized_zero);
    }
    else
    {
        std::fill_n(scaled.data(), scaled.num_elements(), T(0));
    }
 
    // Flip weights by 180 degrees
    SimpleTensor<TW> weights_flipped{ weights.shape(), weights.data_type(), 1, weights.quantization_info(), weights.data_layout() };
#if defined(_OPENMP)
    #pragma omp parallel for
#endif /* _OPENMP */
    for(int ud = 0; ud < weights_upper_dims; ++ud)
    {
        const int offset = ud * weights_width * weights_height;
        for(int y = 0; y < weights_height; ++y)
        {
            for(int x = 0; x < weights_width; ++x)
            {
                weights_flipped[offset + (weights_height - 1 - y) * weights_width + (weights_width - 1 - x)] = weights[offset + y * weights_width + x];
            }
        }
    }
#if defined(_OPENMP)
    #pragma omp parallel for
#endif /* _OPENMP */
    for(int slice = 0; slice < num_2d_slices; ++slice)
    {
        const int offset_slice_in  = slice * width_in * height_in;
        const int offset_slice_out = slice * width_scaled * height_scaled;
        const int start_x          = deconv_pad_left;
        const int start_y          = deconv_pad_top;
        const int end_x            = width_scaled - deconv_pad_right;
        const int end_y            = height_scaled - deconv_pad_bottom;
 
        for(int yi = start_y, in_y = 0; yi < end_y; yi += stride_y, in_y++)
        {
            for(int xi = start_x, in_x = 0; xi < end_x; xi += stride_x, in_x++)
            {
                const T *in  = src.data() + offset_slice_in + in_y * width_in + in_x;
                T       *out = scaled.data() + offset_slice_out + xi + yi * width_scaled;
                *out         = *in;
            }
        }
    }
 
    const PadStrideInfo conv_info(1, 1, 0, 0, 0, 0, DimensionRoundingType::CEIL);
    return convolution_layer(scaled, weights_flipped, bias, output_shape, conv_info, Size2D(1U, 1U), 1, out_qinfo);
}

References ARM_COMPUTE_ERROR_ON, bias, arm_compute::CEIL, arm_compute::test::validation::conv_info, convolution_layer(), SimpleTensor< T >::data_layout(), SimpleTensor< T >::data_type(), arm_compute::test::validation::info, offset(), arm_compute::test::validation::output_shape, arm_compute::QASYMM8, arm_compute::QASYMM8_SIGNED, SimpleTensor< T >::quantization_info(), TensorShape::set(), SimpleTensor< T >::shape(), slice(), arm_compute::test::validation::src, arm_compute::utils::cast::U, weights_height, and weights_width.

deconvolution_layer() [5/6]

template SimpleTensor<uint8_t> arm_compute::test::validation::reference::deconvolution_layer	(	const SimpleTensor< uint8_t > &	src,
		const SimpleTensor< int8_t > &	weights,
		const SimpleTensor< int32_t > &	bias,
		const TensorShape &	output_shape,
		const PadStrideInfo &	info,
		QuantizationInfo	out_quant_info
	)

deconvolution_layer() [6/6]

template SimpleTensor<uint8_t> arm_compute::test::validation::reference::deconvolution_layer	(	const SimpleTensor< uint8_t > &	src,
		const SimpleTensor< uint8_t > &	weights,
		const SimpleTensor< int32_t > &	bias,
		const TensorShape &	output_shape,
		const PadStrideInfo &	info,
		QuantizationInfo	out_quant_info
	)

depth_convert() [1/12]

template SimpleTensor<float> arm_compute::test::validation::reference::depth_convert	(	const SimpleTensor< bfloat16 > &	src,
		DataType	dt_out,
		ConvertPolicy	policy,
		uint32_t	shift
	)

depth_convert() [2/12]

template SimpleTensor< bfloat16 > depth_convert	(	const SimpleTensor< float > &	src,
		DataType	dt_out,
		ConvertPolicy	policy,
		uint32_t	shift
	)

depth_convert() [3/12]

template SimpleTensor< float > depth_convert	(	const SimpleTensor< half > &	src,
		DataType	dt_out,
		ConvertPolicy	policy,
		uint32_t	shift
	)

depth_convert() [4/12]

template SimpleTensor< float > depth_convert	(	const SimpleTensor< int16_t > &	src,
		DataType	dt_out,
		ConvertPolicy	policy,
		uint32_t	shift
	)

depth_convert() [5/12]

template SimpleTensor< float > depth_convert	(	const SimpleTensor< int32_t > &	src,
		DataType	dt_out,
		ConvertPolicy	policy,
		uint32_t	shift
	)

depth_convert() [6/12]

template SimpleTensor< float > depth_convert	(	const SimpleTensor< int64_t > &	src,
		DataType	dt_out,
		ConvertPolicy	policy,
		uint32_t	shift
	)

depth_convert() [7/12]

template SimpleTensor< float > depth_convert	(	const SimpleTensor< int8_t > &	src,
		DataType	dt_out,
		ConvertPolicy	policy,
		uint32_t	shift
	)

depth_convert() [8/12]

SimpleTensor< T2 > depth_convert	(	const SimpleTensor< T1 > &	src,
		DataType	dt_out,
		ConvertPolicy	policy,
		uint32_t	shift
	)

Definition at line 42 of file DepthConvertLayer.cpp.

{
    SimpleTensor<T2> result(src.shape(), dt_out);
 
    // Up-casting
    if(element_size_from_data_type(src.data_type()) < element_size_from_data_type(dt_out))
    {
#if defined(_OPENMP)
        #pragma omp parallel for
#endif /* _OPENMP */
        for(int i = 0; i < src.num_elements(); ++i)
        {
            result[i] = src[i] << shift;
        }
    }
    // Down-casting
    else
    {
#if defined(_OPENMP)
        #pragma omp parallel for
#endif /* _OPENMP */
        for(int i = 0; i < src.num_elements(); ++i)
        {
            T1 val    = src[i] >> shift;
            result[i] = (policy == ConvertPolicy::SATURATE) ? utils::cast::saturate_cast<T2>(val) : static_cast<T2>(val);
        }
    }
    return result;
}

References arm_compute::element_size_from_data_type(), arm_compute::SATURATE, and arm_compute::test::validation::src.

depth_convert() [9/12]

template SimpleTensor< float > depth_convert	(	const SimpleTensor< uint16_t > &	src,
		DataType	dt_out,
		ConvertPolicy	policy,
		uint32_t	shift
	)

depth_convert() [10/12]

template SimpleTensor< float > depth_convert	(	const SimpleTensor< uint32_t > &	src,
		DataType	dt_out,
		ConvertPolicy	policy,
		uint32_t	shift
	)

depth_convert() [11/12]

template SimpleTensor< float > depth_convert	(	const SimpleTensor< uint64_t > &	src,
		DataType	dt_out,
		ConvertPolicy	policy,
		uint32_t	shift
	)

depth_convert() [12/12]

template SimpleTensor< float > depth_convert	(	const SimpleTensor< uint8_t > &	src,
		DataType	dt_out,
		ConvertPolicy	policy,
		uint32_t	shift
	)

depth_to_space() [1/3]

template SimpleTensor<float> arm_compute::test::validation::reference::depth_to_space	(	const SimpleTensor< float > &	src,
		const TensorShape &	dst_shape,
		int32_t	block_shape
	)

depth_to_space() [2/3]

template SimpleTensor<half> arm_compute::test::validation::reference::depth_to_space	(	const SimpleTensor< half > &	src,
		const TensorShape &	dst_shape,
		int32_t	block_shape
	)

depth_to_space() [3/3]

SimpleTensor< T > depth_to_space	(	const SimpleTensor< T > &	src,
		const TensorShape &	dst_shape,
		int32_t	block_shape
	)

Definition at line 38 of file DepthToSpaceLayer.cpp.

{
    ARM_COMPUTE_ERROR_ON(block_shape <= 0);
    SimpleTensor<T> result(dst_shape, src.data_type());
 
    const auto width_in   = static_cast<int>(src.shape()[0]);
    const auto height_in  = static_cast<int>(src.shape()[1]);
    const auto channel_in = static_cast<int>(src.shape()[2]);
    const auto batch_in   = static_cast<int>(src.shape()[3]);
    const int  r          = channel_in / (block_shape * block_shape);
#if defined(_OPENMP)
    #pragma omp parallel for collapse(4)
#endif /* _OPENMP */
    for(int b = 0; b < batch_in; ++b)
    {
        for(int z = 0; z < channel_in; ++z)
        {
            for(int y = 0; y < height_in; ++y)
            {
                for(int x = 0; x < width_in; ++x)
                {
                    const int out_x   = (block_shape * x + (z / r) % block_shape);
                    const int out_y   = (block_shape * y + (z / r) / block_shape);
                    const int out_pos = out_x + dst_shape[0] * out_y + (z % r) * dst_shape[0] * dst_shape[1] + b * dst_shape[0] * dst_shape[1] * dst_shape[2];
                    const int in_pos  = x + width_in * y + z * width_in * height_in + b * width_in * height_in * channel_in;
                    result[out_pos]   = src[in_pos];
                }
            }
        }
    }
 
    return result;
}

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

depthconcatenate_layer()