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 SimpleTensor< bfloat16 >	activation_layer (const SimpleTensor< bfloat16 > &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 , typename TACC = T>
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< float, float, float > (const SimpleTensor< float > &src, const SimpleTensor< float > &weights, const SimpleTensor< float > &bias, SimpleTensor< float > &dst, const Conv3dInfo &conv3d_info)
template SimpleTensor< half >	conv3d< half, half, float > (const SimpleTensor< half > &src, const SimpleTensor< half > &weights, const SimpleTensor< half > &bias, SimpleTensor< half > &dst, const Conv3dInfo &conv3d_info)
template SimpleTensor< uint8_t >	conv3d< uint8_t, int32_t, int32_t > (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< int8_t, int32_t, int32_t > (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< bfloat16 >	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 SimpleTensor< float >	dequantization_layer (const SimpleTensor< int32_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<typename T , typename std::enable_if< is_floating_point< T >::value, int >::type >
void	gemm_accumulate (const SimpleTensor< T > &a, const SimpleTensor< T > &b, const SimpleTensor< T > &c, float alpha, float beta, SimpleTensor< T > &dst)
template SimpleTensor< bfloat16 >	gemm (const SimpleTensor< bfloat16 > &a, const SimpleTensor< bfloat16 > &b, const SimpleTensor< bfloat16 > &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 void	gemm_accumulate (const SimpleTensor< float > &a, const SimpleTensor< float > &b, const SimpleTensor< float > &c, float alpha, float beta, SimpleTensor< float > &dst)
template void	gemm_accumulate (const SimpleTensor< half > &a, const SimpleTensor< half > &b, const SimpleTensor< half > &c, float alpha, float beta, SimpleTensor< half > &dst)
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 T_out , typename T_in , typename T_in_1 >
void	gemmlowp_matrix_multiply_core_accumulate (const SimpleTensor< T_in > &a, const SimpleTensor< T_in_1 > &b, TensorShape shape_c, int32_t a_offset, int32_t b_offset, SimpleTensor< T_out > &dst)
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 void	gemmlowp_matrix_multiply_core_accumulate (const SimpleTensor< int8_t > &a, const SimpleTensor< int8_t > &b, TensorShape shape_c, int32_t a_offset, int32_t b_offset, SimpleTensor< int32_t > &dst)
template void	gemmlowp_matrix_multiply_core_accumulate (const SimpleTensor< uint8_t > &a, const SimpleTensor< uint8_t > &b, TensorShape shape_c, int32_t a_offset, int32_t b_offset, SimpleTensor< int32_t > &dst)
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 T1 , typename T2 , typename T3 >
void	gemmlowp_matrix_multiply_core_accumulate (const SimpleTensor< T2 > &a, const SimpleTensor< T3 > &b, TensorShape shape_c, int32_t a_offset, int32_t b_offset, SimpleTensor< T1 > &dst_)
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 SimpleTensor< bfloat16 >	permute (const SimpleTensor< bfloat16 > &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 >
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 SimpleTensor< bfloat16 >	reshape_layer (const SimpleTensor< bfloat16 > &src, const TensorShape &output_shape)
template<typename T >
SimpleTensor< T >	reverse (const SimpleTensor< T > &src, const SimpleTensor< int32_t > &axis, bool use_inverted_axis)
template SimpleTensor< uint8_t >	reverse (const SimpleTensor< uint8_t > &src, const SimpleTensor< int32_t > &axis, bool use_inverted_axis)
template SimpleTensor< half >	reverse (const SimpleTensor< half > &src, const SimpleTensor< int32_t > &axis, bool use_inverted_axis)
template SimpleTensor< float >	reverse (const SimpleTensor< float > &src, const SimpleTensor< int32_t > &axis, bool use_inverted_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 >	scatter_layer_internal (const SimpleTensor< T > &src, const SimpleTensor< T > &updates, const SimpleTensor< int32_t > &indices, const TensorShape &out_shape, const ScatterInfo &info)
template<typename T >
SimpleTensor< T >	scatter_layer (const SimpleTensor< T > &src, const SimpleTensor< T > &updates, const SimpleTensor< int32_t > &indices, const TensorShape &out_shape, const ScatterInfo &info)
template SimpleTensor< float >	scatter_layer (const SimpleTensor< float > &src, const SimpleTensor< float > &updates, const SimpleTensor< int32_t > &indices, const TensorShape &out_shape, const ScatterInfo &info)
template SimpleTensor< half >	scatter_layer (const SimpleTensor< half > &src, const SimpleTensor< half > &updates, const SimpleTensor< int32_t > &indices, const TensorShape &out_shape, const ScatterInfo &info)
template SimpleTensor< int32_t >	scatter_layer (const SimpleTensor< int32_t > &src, const SimpleTensor< int32_t > &updates, const SimpleTensor< int32_t > &indices, const TensorShape &out_shape, const ScatterInfo &info)
template SimpleTensor< uint32_t >	scatter_layer (const SimpleTensor< uint32_t > &src, const SimpleTensor< uint32_t > &updates, const SimpleTensor< int32_t > &indices, const TensorShape &out_shape, const ScatterInfo &info)
template SimpleTensor< int16_t >	scatter_layer (const SimpleTensor< int16_t > &src, const SimpleTensor< int16_t > &updates, const SimpleTensor< int32_t > &indices, const TensorShape &out_shape, const ScatterInfo &info)
template SimpleTensor< uint16_t >	scatter_layer (const SimpleTensor< uint16_t > &src, const SimpleTensor< uint16_t > &updates, const SimpleTensor< int32_t > &indices, const TensorShape &out_shape, const ScatterInfo &info)
template SimpleTensor< int8_t >	scatter_layer (const SimpleTensor< int8_t > &src, const SimpleTensor< int8_t > &updates, const SimpleTensor< int32_t > &indices, const TensorShape &out_shape, const ScatterInfo &info)
template SimpleTensor< uint8_t >	scatter_layer (const SimpleTensor< uint8_t > &src, const SimpleTensor< uint8_t > &updates, const SimpleTensor< int32_t > &indices, const TensorShape &out_shape, const ScatterInfo &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(), 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 > static_cast<T>(0) ? x : static_cast<T>(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 > static_cast<T>(0) ? x : static_cast<T>(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/5]

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

activation_layer() [2/5]

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

activation_layer() [3/5]

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

activation_layer() [4/5]

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

activation_layer() [5/5]

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

Definition at line 39 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(), 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 86 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 74 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 62 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 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, 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::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::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<int32_t> axis{ TensorShape(2U), DataType::S32 };
    std::copy(axis_v.begin(), axis_v.begin() + axis.shape().x(), axis.data());
    auto flipped_w = reverse(w, axis, /* use_inverted_axis */ false);
 
    // 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(), arm_compute::S32, slice(), arm_compute::test::validation::src, arm_compute::utils::cast::U, and arm_compute::test::validation::w.

conv3d()

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, TACC>(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, 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(), Size3D::y(), and Size3D::z().

conv3d< float, float, float >()

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

conv3d< half, half, float >()

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

conv3d< int8_t, int32_t, int32_t >()

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

conv3d< uint8_t, int32_t, int32_t >()

template SimpleTensor<uint8_t> arm_compute::test::validation::reference::conv3d< uint8_t, int32_t, int32_t >	(	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::cpu::channel_idx, arm_compute::coords2index(), arm_compute::test::validation::dst, arm_compute::get_data_layout_dimension_index(), arm_compute::HEIGHT, arm_compute::cpu::height_idx, arm_compute::index2coords(), arm_compute::NCHW, arm_compute::NHWC, arm_compute::test::validation::src, arm_compute::WIDTH, arm_compute::cpu::width_idx, 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, Dimensions< T >::x(), and Dimensions< T >::y().

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<bfloat16> 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() [1/4]

template SimpleTensor<float> arm_compute::test::validation::reference::depthconcatenate_layer	(	const std::vector< SimpleTensor< float >> &	srcs,
		SimpleTensor< float > &	dst
	)

depthconcatenate_layer() [2/4]

template SimpleTensor<half> arm_compute::test::validation::reference::depthconcatenate_layer	(	const std::vector< SimpleTensor< half >> &	srcs,
		SimpleTensor< half > &	dst
	)

depthconcatenate_layer() [3/4]

SimpleTensor< T > depthconcatenate_layer	(	const std::vector< SimpleTensor< T >> &	srcs,
		SimpleTensor< T > &	dst
	)

Definition at line 37 of file DepthConcatenateLayer.cpp.

{
    // Create reference
    std::vector<TensorShape> shapes;
    shapes.reserve(srcs.size());
    for(const auto &src : srcs)
    {
        shapes.emplace_back(src.shape());
    }
 
    // Compute reference
    int       depth_offset                = 0;
    const int width_out                   = dst.shape().x();
    const int height_out                  = dst.shape().y();
    const int depth_out                   = dst.shape().z();
    const int out_stride_z                = width_out * height_out;
    const int batches                     = dst.shape().total_size_upper(3);
    auto have_different_quantization_info = [&](const SimpleTensor<T> &tensor)
    {
        return tensor.quantization_info() != dst.quantization_info();
    };
 
    if(srcs[0].data_type() == DataType::QASYMM8 && std::any_of(srcs.cbegin(), srcs.cend(), have_different_quantization_info))
    {
#if defined(_OPENMP)
        #pragma omp parallel for
#endif /* _OPENMP */
        for(int b = 0; b < batches; ++b)
        {
            // input tensors can have smaller width and height than the output, so for each output's slice we need to requantize 0 (as this is the value
            // used in NEFillBorderKernel by NEDepthConcatenateLayer) using the corresponding quantization info for that particular slice/input tensor.
            int slice = 0;
            for(const auto &src : srcs)
            {
                auto                          ptr_slice = static_cast<T *>(dst(Coordinates(0, 0, slice, b)));
                const auto                    num_elems_in_slice((dst.num_elements() / depth_out) * src.shape().z());
                const UniformQuantizationInfo iq_info = src.quantization_info().uniform();
                const UniformQuantizationInfo oq_info = dst.quantization_info().uniform();
 
                std::transform(ptr_slice, ptr_slice + num_elems_in_slice, ptr_slice, [&](T)
                {
                    return quantize_qasymm8(dequantize_qasymm8(0, iq_info), oq_info);
                });
                slice += src.shape().z();
            }
        }
    }
    else
    {
        std::fill_n(dst.data(), dst.num_elements(), 0);
    }
 
    for(const auto &src : srcs)
    {
        ARM_COMPUTE_ERROR_ON(depth_offset >= depth_out);
        ARM_COMPUTE_ERROR_ON(batches != static_cast<int>(src.shape().total_size_upper(3)));
 
        const int width  = src.shape().x();
        const int height = src.shape().y();
        const int depth  = src.shape().z();
        const int x_diff = (width_out - width) / 2;
        const int y_diff = (height_out - height) / 2;
 
        const T *src_ptr = src.data();
 
        for(int b = 0; b < batches; ++b)
        {
            const size_t offset_to_first_element = b * out_stride_z * depth_out + depth_offset * out_stride_z + y_diff * width_out + x_diff;
 
            for(int d = 0; d < depth; ++d)
            {
                for(int r = 0; r < height; ++r)
                {
                    if(src.data_type() == DataType::QASYMM8 && src.quantization_info() != dst.quantization_info())
                    {
                        const UniformQuantizationInfo iq_info = src.quantization_info().uniform();
                        const UniformQuantizationInfo oq_info = dst.quantization_info().uniform();
                        std::transform(src_ptr, src_ptr + width, dst.data() + offset_to_first_element + d * out_stride_z + r * width_out, [&](T t)
                        {
                            const float dequantized_input = dequantize_qasymm8(t, iq_info);
                            return quantize_qasymm8(dequantized_input, oq_info);
                        });
                        src_ptr += width;
                    }
                    else
                    {
                        std::copy(src_ptr, src_ptr + width, dst.data() + offset_to_first_element + d * out_stride_z + r * width_out);
                        src_ptr += width;
                    }
                }
            }
        }
 
        depth_offset += depth;
    }
 
    return dst;
}

References ARM_COMPUTE_ERROR_ON, arm_compute::test::validation::b, batches, copy(), arm_compute::test::validation::data_type, arm_compute::dequantize_qasymm8(), arm_compute::test::validation::dst, arm_compute::QASYMM8, arm_compute::quantize_qasymm8(), slice(), arm_compute::test::validation::src, tf_frozen_model_extractor::t, and tensor.

depthconcatenate_layer() [4/4]

template SimpleTensor<uint8_t> arm_compute::test::validation::reference::depthconcatenate_layer	(	const std::vector< SimpleTensor< uint8_t >> &	srcs,
		SimpleTensor< uint8_t > &	dst
	)

depthwise_convolution() [1/6]

SimpleTensor<float> arm_compute::test::validation::reference::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
	)

Definition at line 238 of file DepthwiseConvolutionLayer.cpp.

{
    return depthwise_convolution_fp(src, weights, biases, dst_shape, conv_info, depth_multiplier, dilation, out_quant_info);
}

References arm_compute::test::validation::conv_info, arm_compute::test::validation::dst_shape, and arm_compute::test::validation::src.

Referenced by arm_compute::test::validation::TEST_CASE().

depthwise_convolution() [2/6]

SimpleTensor<half> arm_compute::test::validation::reference::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
	)

Definition at line 245 of file DepthwiseConvolutionLayer.cpp.

{
    return depthwise_convolution_fp(src, weights, biases, dst_shape, conv_info, depth_multiplier, dilation, out_quant_info);
}

References arm_compute::test::validation::conv_info, arm_compute::test::validation::dst_shape, and arm_compute::test::validation::src.

depthwise_convolution() [3/6]

SimpleTensor<int8_t> arm_compute::test::validation::reference::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
	)

Definition at line 266 of file DepthwiseConvolutionLayer.cpp.

{
    return depthwise_convolution_quantized<int8_t, int8_t, int32_t>(src, weights, biases, dst_shape, conv_info, depth_multiplier, dilation, out_quant_info);
}

References arm_compute::test::validation::conv_info, arm_compute::test::validation::dst_shape, and arm_compute::test::validation::src.

depthwise_convolution() [4/6]

SimpleTensor<T> arm_compute::test::validation::reference::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)
	)

depthwise_convolution() [5/6]

SimpleTensor<uint8_t> arm_compute::test::validation::reference::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
	)

Definition at line 259 of file DepthwiseConvolutionLayer.cpp.

{
    return depthwise_convolution_quantized<uint8_t, int8_t, int32_t>(src, weights, biases, dst_shape, conv_info, depth_multiplier, dilation, out_quant_info);
}

References arm_compute::test::validation::conv_info, arm_compute::test::validation::dst_shape, and arm_compute::test::validation::src.

depthwise_convolution() [6/6]

SimpleTensor<uint8_t> arm_compute::test::validation::reference::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
	)

Definition at line 252 of file DepthwiseConvolutionLayer.cpp.

{
    return depthwise_convolution_quantized<uint8_t, uint8_t, int32_t>(src, weights, biases, dst_shape, conv_info, depth_multiplier, dilation, out_quant_info);
}

References arm_compute::test::validation::conv_info, arm_compute::test::validation::dst_shape, and arm_compute::test::validation::src.

depthwise_separable_convolution_layer()

SimpleTensor<T> arm_compute::test::validation::reference::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
	)

dequantization_layer() [1/5]

template SimpleTensor< float > dequantization_layer

(

const SimpleTensor< int16_t > &

src

)

dequantization_layer() [2/5]

template SimpleTensor<float> arm_compute::test::validation::reference::dequantization_layer

(

const SimpleTensor< int32_t > &

src

)

dequantization_layer() [3/5]

template SimpleTensor< float > dequantization_layer

(

const SimpleTensor< int8_t > &

src

)

dequantization_layer() [4/5]

SimpleTensor< TOut > dequantization_layer

(

const SimpleTensor< TIn > &

src

)

Definition at line 70 of file DequantizationLayer.cpp.

{
    const DataType src_data_type = src.data_type();
    const DataType dst_data_type = std::is_same<TOut, float>::value ? DataType::F32 : DataType::F16;
 
    SimpleTensor<TOut> dst{ src.shape(), dst_data_type };
 
    if(is_data_type_quantized_per_channel(src_data_type))
    {
        const int WH = src.shape().x() * src.shape().y();
        const int C  = src.shape().z();
        const int N  = src.shape().total_size() / (WH * C);
 
        const std::vector<float> qscales = src.quantization_info().scale();
#if defined(_OPENMP)
        #pragma omp parallel for collapse(2)
#endif /* _OPENMP */
        for(int n = 0; n < N; ++n)
        {
            for(int c = 0; c < C; ++c)
            {
                const size_t                  idx           = n * C * WH + c * WH;
                const UniformQuantizationInfo channel_qinfo = { qscales[c], 0 };
 
                // Dequantize slice
                for(int s = 0; s < WH; ++s)
                {
                    dst[idx + s] = dequantize<TOut>(static_cast<TIn>(src[idx + s]), channel_qinfo, src_data_type);
                }
            }
        }
    }
    else
    {
        const UniformQuantizationInfo &quantization_info = src.quantization_info().uniform();
        ARM_COMPUTE_ERROR_ON(quantization_info.offset != 0 && src_data_type == DataType::QSYMM8);
#if defined(_OPENMP)
        #pragma omp parallel for
#endif /* _OPENMP */
        for(int i = 0; i < src.num_elements(); ++i)
        {
            dst[i] = static_cast<TOut>(dequantize<TOut>(static_cast<TIn>(src[i]), quantization_info, src_data_type));
        }
    }
 
    return dst;
}

References ARM_COMPUTE_ERROR_ON, arm_compute::test::validation::dst, arm_compute::F16, arm_compute::F32, arm_compute::is_data_type_quantized_per_channel(), N, UniformQuantizationInfo::offset, arm_compute::QSYMM8, and arm_compute::test::validation::src.

dequantization_layer() [5/5]

template SimpleTensor< float > dequantization_layer

(

const SimpleTensor< uint8_t > &

src

)

dft_1d() [1/3]

template SimpleTensor<float> arm_compute::test::validation::reference::dft_1d	(	const SimpleTensor< float > &	src,
		FFTDirection	direction
	)

dft_1d() [2/3]

template SimpleTensor<half> arm_compute::test::validation::reference::dft_1d	(	const SimpleTensor< half > &	src,
		FFTDirection	direction
	)

dft_1d() [3/3]

SimpleTensor< T > dft_1d	(	const SimpleTensor< T > &	src,
		FFTDirection	direction
	)

Performs an one dimensional DFT on a complex input.

Parameters

[in]	src	Source tensor.
[in]	direction	Direction of the DFT.

Returns

Complex output of same length as input.

Definition at line 330 of file DFT.cpp.

{
    auto dst = dft_1d_core(src, direction);
    if(direction == FFTDirection::Inverse)
    {
        const T scaling_factor = T(dst.shape()[0]);
        scale(dst, scaling_factor);
    }
    return dst;
}

References arm_compute::test::validation::dst, Inverse, scale(), and arm_compute::test::validation::src.

Referenced by arm_compute::test::validation::DATA_TEST_CASE().

dft_2d() [1/3]

template SimpleTensor<float> arm_compute::test::validation::reference::dft_2d	(	const SimpleTensor< float > &	src,
		FFTDirection	direction
	)

dft_2d() [2/3]

template SimpleTensor<half> arm_compute::test::validation::reference::dft_2d	(	const SimpleTensor< half > &	src,
		FFTDirection	direction
	)

dft_2d() [3/3]

SimpleTensor< T > dft_2d	(	const SimpleTensor< T > &	src,
		FFTDirection	direction
	)

Performs a two dimensional DFT on a complex input.

Parameters

[in]	src	Source tensor.
[in]	direction	Direction of the DFT.

Returns

Complex output of same length as input.

Definition at line 370 of file DFT.cpp.

{
    ARM_COMPUTE_ERROR_ON(src.num_channels() != 2);
 
    if(direction == FFTDirection::Forward)
    {
        auto first_pass  = dft_1d_core(src, direction);
        auto transposed  = permute(first_pass, PermutationVector(1U, 0U));
        auto second_pass = dft_1d_core(transposed, direction);
        return permute(second_pass, PermutationVector(1U, 0U));
    }
    else
    {
        auto transposed   = permute(src, PermutationVector(1U, 0U));
        auto first_pass   = dft_1d_core(transposed, direction);
        auto transposed_2 = permute(first_pass, PermutationVector(1U, 0U));
        auto dst          = dft_1d_core(transposed_2, direction);
 
        const T scaling_factor = T(dst.shape()[0] * dst.shape()[1]);
        scale(dst, scaling_factor);
 
        return dst;
    }
}

References ARM_COMPUTE_ERROR_ON, arm_compute::test::validation::dst, Forward, permute(), scale(), arm_compute::test::validation::src, and arm_compute::utils::cast::U.

Referenced by arm_compute::test::validation::DATA_TEST_CASE().

elementwise_unary() [1/6]

template SimpleTensor<float> arm_compute::test::validation::reference::elementwise_unary	(	const SimpleTensor< float > &	src,
		SimpleTensor< float > &	dst,
		ElementWiseUnary	op
	)

elementwise_unary() [2/6]

template SimpleTensor<half> arm_compute::test::validation::reference::elementwise_unary	(	const SimpleTensor< half > &	src,
		SimpleTensor< half > &	dst,
		ElementWiseUnary	op
	)

elementwise_unary() [3/6]

template SimpleTensor<int32_t> arm_compute::test::validation::reference::elementwise_unary	(	const SimpleTensor< int32_t > &	src,
		SimpleTensor< int32_t > &	dst,
		ElementWiseUnary	op
	)

elementwise_unary() [4/6]

SimpleTensor<int8_t> arm_compute::test::validation::reference::elementwise_unary	(	const SimpleTensor< int8_t > &	src,
		SimpleTensor< int8_t > &	dst,
		ElementWiseUnary	op
	)

Definition at line 70 of file ElementwiseUnary.cpp.

{
    if(dst.data_type() == DataType::QASYMM8_SIGNED)
    {
        SimpleTensor<float> src_tmp = convert_from_asymmetric(src);
        SimpleTensor<float> dst_tmp(src.shape(), DataType::F32);
        for(int i = 0; i < src.num_elements(); ++i)
        {
            switch(op)
            {
                case ElementWiseUnary::RSQRT:
                    if(src_tmp[i] != 0)
                    {
                        dst_tmp[i] = 1.f / std::sqrt(src_tmp[i]);
                    }
                    else
                    {
                       // rsqrt(0) give 'inf' so set to the maximum in int8: 127
                       dst_tmp[i] = (127.0f - dst.quantization_info().uniform().offset)  * dst.quantization_info().uniform().scale ;
                    }
                    break;
 
                case ElementWiseUnary::LOG:
                    if(src_tmp[i] != 0)
                    {
                        dst_tmp[i] = std::log(src_tmp[i]);
                    }
                    else
                    {
                       dst_tmp[i] = (-128.0f - dst.quantization_info().uniform().offset)  * dst.quantization_info().uniform().scale ;
                    }
                    break;
 
                default:
                    elementwise_unary(src_tmp, dst_tmp, op);
                    break;
            }
        }
        dst = convert_to_asymmetric<int8_t>(dst_tmp, dst.quantization_info());
    }
    else
    {
        ARM_COMPUTE_ERROR("Not implemented");
    }
    return dst;
}

References ARM_COMPUTE_ERROR, arm_compute::test::validation::convert_from_asymmetric(), arm_compute::test::validation::dst, elementwise_unary(), arm_compute::F32, arm_compute::LOG, arm_compute::QASYMM8_SIGNED, arm_compute::RSQRT, and arm_compute::test::validation::src.

elementwise_unary() [5/6]

SimpleTensor< T > elementwise_unary	(	const SimpleTensor< T > &	src,
		SimpleTensor< T > &	dst,
		ElementWiseUnary	op
	)

Definition at line 36 of file ElementwiseUnary.cpp.

{
    for(int i = 0; i < src.num_elements(); ++i)
    {
        switch(op)
        {
            case ElementWiseUnary::RSQRT:
                dst[i] = 1.f / std::sqrt(src[i]);
                break;
            case ElementWiseUnary::EXP:
                dst[i] = std::exp(src[i]);
                break;
            case ElementWiseUnary::NEG:
                dst[i] = -src[i];
                break;
            case ElementWiseUnary::LOG:
                dst[i] = std::log(src[i]);
                break;
            case ElementWiseUnary::ABS:
                dst[i] = std::abs(src[i]);
                break;
            case ElementWiseUnary::SIN:
                dst[i] = std::sin(src[i]);
                break;
            case ElementWiseUnary::ROUND:
                dst[i] = arm_compute::support::cpp11::nearbyint(src[i]);
                break;
            default:
                ARM_COMPUTE_ERROR("Not implemented");
        }
    }
    return dst;
}

References arm_compute::ABS, ARM_COMPUTE_ERROR, arm_compute::test::validation::dst, arm_compute::EXP, arm_compute::LOG, arm_compute::support::cpp11::nearbyint(), arm_compute::NEG, arm_compute::ROUND, arm_compute::RSQRT, arm_compute::SIN, and arm_compute::test::validation::src.

Referenced by elementwise_unary().

elementwise_unary() [6/6]

SimpleTensor<uint8_t> arm_compute::test::validation::reference::elementwise_unary	(	const SimpleTensor< uint8_t > &	src,
		SimpleTensor< uint8_t > &	dst,
		ElementWiseUnary	op
	)

Definition at line 117 of file ElementwiseUnary.cpp.

{
    if(dst.data_type() == DataType::QASYMM8)
    {
        SimpleTensor<float> src_tmp = convert_from_asymmetric(src);
        SimpleTensor<float> dst_tmp(src.shape(), DataType::F32);
        for(int i = 0; i < src.num_elements(); ++i)
        {
            switch(op)
            {
                case ElementWiseUnary::RSQRT:
                    if(src_tmp[i] != 0)
                    {
                        dst_tmp[i] = 1.f / std::sqrt(src_tmp[i]);
                    }
                    else
                    {
                        // rsqrt(0) give 'inf' so set to the maximum in uint8: 255
                        dst_tmp[i] = (255.0f - dst.quantization_info().uniform().offset)* dst.quantization_info().uniform().scale;
                    }
                    break;
 
                case ElementWiseUnary::LOG:
                    if(src_tmp[i] != 0)
                    {
                        dst_tmp[i] = std::log(src_tmp[i]);
                    }
                    else
                    {
                        dst_tmp[i] = -dst.quantization_info().uniform().offset * dst.quantization_info().uniform().scale;
                    }
                    break;
 
                default:
                    elementwise_unary(src_tmp, dst_tmp, op);
                    break;
            }
        }
        dst = convert_to_asymmetric<uint8_t>(dst_tmp, dst.quantization_info());
    }
    else
    {
        ARM_COMPUTE_ERROR("Not implemented");
    }
    return dst;
}

References ARM_COMPUTE_ERROR, arm_compute::test::validation::convert_from_asymmetric(), arm_compute::test::validation::dst, elementwise_unary(), arm_compute::F32, arm_compute::LOG, arm_compute::QASYMM8, arm_compute::RSQRT, and arm_compute::test::validation::src.

erode() [1/2]

SimpleTensor< T > erode	(	const SimpleTensor< T > &	src,
		BorderMode	border_mode,
		T	constant_border_value
	)

Definition at line 41 of file Erode.cpp.

{
    /*
             -1   x  +1
         -1 [tl][tc][tr] -1
          y [ml][xy][mr]  y
         +1 [bl][bc][br] +1
             -1   x  +1
        erode:
        dst(x, y) = min[ src(x', y') for x-1<=x'<=x+1, y-1<=y'<=y+1 ] = min({tl, tc, tr, ml, xy, mr, bl, bc, br})
    */
    SimpleTensor<T> dst(src.shape(), src.data_type());
 
    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)
    {
        Coordinates coord = index2coord(src.shape(), i);
        const int   x     = coord.x();
        const int   y     = coord.y();
 
        std::array<T, 9> neighbours = { { 0 } };
        for(int row = y - 1, j = 0; row <= y + 1; ++row)
        {
            for(int col = x - 1; col <= x + 1; ++col, ++j)
            {
                coord.set(0, col);
                coord.set(1, row);
                neighbours[j] = tensor_elem_at(src, coord, border_mode, constant_border_value);
            }
        }
 
        dst[i] = *std::min_element(neighbours.cbegin(), neighbours.cend());
    }
 
    return dst;
}

References arm_compute::test::validation::dst, arm_compute::test::index2coord(), Dimensions< T >::set(), arm_compute::test::validation::src, arm_compute::test::validation::tensor_elem_at(), Dimensions< T >::x(), and Dimensions< T >::y().

erode() [2/2]

template SimpleTensor<uint8_t> arm_compute::test::validation::reference::erode	(	const SimpleTensor< uint8_t > &	src,
		BorderMode	border_mode,
		uint8_t	constant_border_value
	)

flatten_layer() [1/3]

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

flatten_layer() [2/3]

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

flatten_layer() [3/3]

SimpleTensor< T > flatten_layer	(	const SimpleTensor< T > &	src,
		const TensorShape &	shape_flatten
	)

Definition at line 35 of file FlattenLayer.cpp.

{
    SimpleTensor<T> dst(shape_flatten, src.data_type(), 1);
 
    // Note: Since the reference implementation does not use padding bytes, we can copy directly the content of the source tensor
    std::copy(src.data(), src.data() + src.num_elements(), dst.data());
 
    return dst;
}

References copy(), arm_compute::test::validation::dst, and arm_compute::test::validation::src.

floor_layer() [1/3]

template SimpleTensor<float> arm_compute::test::validation::reference::floor_layer

(

const SimpleTensor< float > &

src

)

floor_layer() [2/3]

template SimpleTensor<half> arm_compute::test::validation::reference::floor_layer

(

const SimpleTensor< half > &

src

)

floor_layer() [3/3]

SimpleTensor< T > floor_layer

(

const SimpleTensor< T > &

src

)

Definition at line 39 of file Floor.cpp.

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

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

fully_connected_layer() [1/5]

template SimpleTensor<float> arm_compute::test::validation::reference::fully_connected_layer	(	const SimpleTensor< float > &	src,
		const SimpleTensor< float > &	weights,
		const SimpleTensor< float > &	bias,
		const TensorShape &	dst_shape,
		QuantizationInfo	out_quant_info
	)

fully_connected_layer() [2/5]

template SimpleTensor<half> arm_compute::test::validation::reference::fully_connected_layer	(	const SimpleTensor< half > &	src,
		const SimpleTensor< half > &	weights,
		const SimpleTensor< half > &	bias,
		const TensorShape &	dst_shape,
		QuantizationInfo	out_quant_info
	)

fully_connected_layer() [3/5]

template SimpleTensor<int8_t> arm_compute::test::validation::reference::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
	)

fully_connected_layer() [4/5]

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
	)

Definition at line 115 of file FullyConnectedLayer.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{ TensorShape{ dst_shape }, src.data_type(), 1, out_quant_info };
 
    // Health checks
    const int          num_batch_dimensions = std::max(0, static_cast<int>(dst_shape.num_dimensions()) - 1);
    const int          num_input_dimensions = src.shape().num_dimensions() - num_batch_dimensions;
    const unsigned int linear_input_size    = src.shape().total_size_lower(num_input_dimensions);
 
    ARM_COMPUTE_UNUSED(num_batch_dimensions);
    ARM_COMPUTE_UNUSED(num_input_dimensions);
    ARM_COMPUTE_UNUSED(linear_input_size);
    ARM_COMPUTE_ERROR_ON(weights.shape().x() != linear_input_size);
    ARM_COMPUTE_ERROR_ON(weights.shape().y() != bias.shape().x());
    ARM_COMPUTE_ERROR_ON(weights.shape().y() != dst.shape().x());
 
    // Compute reference
    const int cols_weights = weights.shape().x();
    const int rows_weights = weights.shape().y();
    const int num_batches  = dst_shape.total_size_upper(1);
 
    for(int k = 0; k < num_batches; ++k)
    {
        const int offset_in  = k * cols_weights;
        const int offset_out = k * rows_weights;
 
        vector_matrix_multiply<T>(src,
                                  weights,
                                  bias,
                                  dst,
                                  offset_in,
                                  offset_out,
                                  cols_weights,
                                  rows_weights);
    }
 
    return dst;
}

References ARM_COMPUTE_ERROR_ON, ARM_COMPUTE_UNUSED, bias, arm_compute::test::validation::dst, arm_compute::test::validation::dst_shape, Dimensions< T >::num_dimensions(), SimpleTensor< T >::shape(), arm_compute::test::validation::src, and TensorShape::total_size_upper().

fully_connected_layer() [5/5]

template SimpleTensor<uint8_t> arm_compute::test::validation::reference::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
	)

fuse_batch_normalization_conv_layer() [1/3]

template void arm_compute::test::validation::reference::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
	)

fuse_batch_normalization_conv_layer() [2/3]

template void arm_compute::test::validation::reference::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
	)

fuse_batch_normalization_conv_layer() [3/3]

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
	)

Definition at line 71 of file FuseBatchNormalization.cpp.

{
    const auto *w_data = w.data();
    const auto *b_data = b.data();
 
    auto *w_fused_data = w_fused.data();
    auto *b_fused_data = b_fused.data();
 
    const unsigned int width  = w.shape()[0];
    const unsigned int height = w.shape()[1];
    const unsigned int dim2   = w.shape()[2];
    const unsigned int dim3   = w.shape()[3];
 
    for(unsigned int b = 0; b < dim3; ++b)
    {
        const auto mean_val  = mean.data()[b];
        const auto var_val   = var.data()[b];
        const auto beta_val  = beta.data()[b];
        const auto gamma_val = gamma.data()[b];
 
        for(unsigned int i = 0; i < width * height * dim2; ++i)
        {
            unsigned int index = i + b * width * height * dim2;
 
            w_fused_data[index] = (gamma_val * (w_data[index])) / sqrt(var_val + epsilon);
        }
 
        b_fused_data[b] = (b_data[b] - mean_val) / sqrt(var_val + epsilon) * gamma_val + beta_val;
    }
}

References arm_compute::test::validation::b, SimpleTensor< T >::data(), arm_compute::quantization::epsilon, and arm_compute::test::validation::w.

fuse_batch_normalization_dwc_layer() [1/3]

template void arm_compute::test::validation::reference::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
	)

fuse_batch_normalization_dwc_layer() [2/3]

template void arm_compute::test::validation::reference::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
	)

fuse_batch_normalization_dwc_layer() [3/3]

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
	)

Definition at line 36 of file FuseBatchNormalization.cpp.

{
    const auto *w_data = w.data();
    const auto *b_data = b.data();
 
    auto *w_fused_data = w_fused.data();
    auto *b_fused_data = b_fused.data();
 
    const unsigned int width  = w.shape()[0];
    const unsigned int height = w.shape()[1];
    const unsigned int dim2   = w.shape()[2];
 
#if defined(_OPENMP)
    #pragma omp parallel for
#endif /* _OPENMP */
    for(unsigned int b = 0; b < dim2; ++b)
    {
        const auto mean_val  = mean.data()[b];
        const auto var_val   = var.data()[b];
        const auto beta_val  = beta.data()[b];
        const auto gamma_val = gamma.data()[b];
 
        for(unsigned int i = 0; i < width * height; ++i)
        {
            unsigned int index = i + b * width * height;
 
            w_fused_data[index] = (gamma_val * (w_data[index])) / sqrt(var_val + epsilon);
        }
 
        b_fused_data[b] = (b_data[b] - mean_val) / sqrt(var_val + epsilon) * gamma_val + beta_val;
    }
}

References arm_compute::test::validation::b, SimpleTensor< T >::data(), arm_compute::quantization::epsilon, and arm_compute::test::validation::w.

gather() [1/5]

template SimpleTensor<float> arm_compute::test::validation::reference::gather	(	const SimpleTensor< float > &	src,
		const SimpleTensor< uint32_t > &	indices,
		uint32_t	actual_axis
	)

gather() [2/5]

template SimpleTensor<half> arm_compute::test::validation::reference::gather	(	const SimpleTensor< half > &	src,
		const SimpleTensor< uint32_t > &	indices,
		uint32_t	actual_axis
	)

gather() [3/5]

SimpleTensor< T > gather	(	const SimpleTensor< T > &	src,
		const SimpleTensor< uint32_t > &	indices,
		uint32_t	actual_axis
	)

Definition at line 40 of file Gather.cpp.

{
    const TensorShape dst_shape   = arm_compute::misc::shape_calculator::compute_gather_shape(src.shape(), indices.shape(), actual_axis);
    SimpleTensor<T>   dst(dst_shape, src.data_type());
 
    const auto        src_ptr     = static_cast<const T *>(src.data());
    const auto        indices_ptr = static_cast<const uint32_t *>(indices.data());
    const auto        dst_ptr     = static_cast<T *>(dst.data());
 
    const uint32_t index_limit = src.shape()[actual_axis];
 
    Window win;
    win.use_tensor_dimensions(dst_shape);
 
    execute_window_loop(win, [&](const Coordinates &dst_coords) {
        const auto dst_addr = coords2index(dst.shape(), dst_coords);
 
        // Calculate the coordinates of the index value.
        Coordinates idx_coords;
 
        for(size_t i = 0; i < indices.shape().num_dimensions(); ++i)
        {
            idx_coords.set(i, dst_coords[i + actual_axis]);
        }
 
        const auto index = indices_ptr[coords2index(indices.shape(), idx_coords)];
 
        if(index < index_limit)
        {
            // Calculate the coordinates of the source data.
            Coordinates src_coords;
 
            for(size_t i = 0; i < actual_axis; ++i)
            {
                src_coords.set(i, dst_coords[i]);
            }
 
            src_coords.set(actual_axis, index);
 
            for(size_t i = actual_axis + 1; i < src.shape().num_dimensions(); ++i)
            {
                src_coords.set(i, dst_coords[i + indices.shape().num_dimensions() - 1]);
            }
 
            // Copy the data.
            const auto src_addr = coords2index(src.shape(), src_coords);
            dst_ptr[dst_addr] = src_ptr[src_addr];
        }
        else
        {
            dst_ptr[dst_addr] = 0;
        }
    });
 
    return dst;
}

References arm_compute::misc::shape_calculator::compute_gather_shape(), arm_compute::coords2index(), SimpleTensor< T >::data(), arm_compute::test::validation::dst, arm_compute::test::validation::dst_shape, arm_compute::execute_window_loop(), Dimensions< T >::set(), SimpleTensor< T >::shape(), arm_compute::test::validation::src, and Window::use_tensor_dimensions().

gather() [4/5]

template SimpleTensor<uint16_t> arm_compute::test::validation::reference::gather	(	const SimpleTensor< uint16_t > &	src,
		const SimpleTensor< uint32_t > &	indices,
		uint32_t	actual_axis
	)

gather() [5/5]

template SimpleTensor<uint8_t> arm_compute::test::validation::reference::gather	(	const SimpleTensor< uint8_t > &	src,
		const SimpleTensor< uint32_t > &	indices,
		uint32_t	actual_axis
	)

gemm() [1/4]

template SimpleTensor<bfloat16> arm_compute::test::validation::reference::gemm	(	const SimpleTensor< bfloat16 > &	a,
		const SimpleTensor< bfloat16 > &	b,
		const SimpleTensor< bfloat16 > &	c,
		float	alpha,
		float	beta
	)

gemm() [2/4]

template SimpleTensor<float> arm_compute::test::validation::reference::gemm	(	const SimpleTensor< float > &	a,
		const SimpleTensor< float > &	b,
		const SimpleTensor< float > &	c,
		float	alpha,
		float	beta
	)

gemm() [3/4]

template SimpleTensor<half> arm_compute::test::validation::reference::gemm	(	const SimpleTensor< half > &	a,
		const SimpleTensor< half > &	b,
		const SimpleTensor< half > &	c,
		float	alpha,
		float	beta
	)

gemm() [4/4]

SimpleTensor< T > gemm	(	const SimpleTensor< T > &	a,
		const SimpleTensor< T > &	b,
		const SimpleTensor< T > &	c,
		float	alpha,
		float	beta
	)

Definition at line 40 of file GEMM.cpp.

{
    // Create reference
    SimpleTensor<T> dst{c.shape(), c.data_type(), 1};
 
    // Compute reference
    const int M = a.shape().y();
    const int N = b.shape().x();
    const int K = a.shape().x();
    const int D = a.shape().z(); // Number of matrices in a batch
    const int W = a.shape()[3];  // Number of batched-gemm (Winograd case)
 
    const int a_stride_z = K * M;
    const int a_stride_w = K * M * D;
 
    const int b_stride_z =
        b.shape().num_dimensions() > 2
        ? N * K
        : 0; // Do not slide the matrix B along the 3th dimension in case matrix B has less than 3 dimensions
    int b_stride_w =
        b.shape().num_dimensions() > 3
        ? K * N * D
        : 0; // Do not slide the matrix B along the 4th dimension in case matrix B has less than 4 dimensions
 
    // Note: There are 3 gemm types: batched-gemm, multi-gemm, and batched of multi-gemms. The third dimension of tensor b is overloaded when tensor b has exactly 3 dimensions:
    // it can be either number of batches or multis. Batched-GEMM computation is detected only when the third dimension of "a" and "c" tensors is 1 and the number of dimensions is 4
    const bool is_batched_gemm = b.shape().num_dimensions() == 3 && a.shape().num_dimensions() == 4 &&
                                 c.shape().num_dimensions() == 4 && a.shape()[2] == 1 && c.shape()[2] == 1;
 
    // Batched-GEMM
    if (is_batched_gemm)
    {
        b_stride_w = b_stride_z;
    }
 
    const int c_stride_z = N * M;
    const int c_stride_w = N * M * D;
 
#if defined(_OPENMP) && !(defined(__arm__) && defined(__ANDROID__))
    #pragma omp parallel for collapse(2)
#endif /* _OPENMP */
    for (int w = 0; w < W; ++w)
    {
        for (int depth = 0; depth < D; ++depth)
        {
            const int base_addr_a = depth * a_stride_z + w * a_stride_w;
            const int base_addr_b = depth * b_stride_z + w * b_stride_w;
            const int base_addr_c = depth * c_stride_z + w * c_stride_w;
 
            for (int row = 0; row < M; ++row)
            {
                for (int col = 0; col < N; ++col)
                {
                    T acc(0);
 
                    for (int k = 0; k < K; ++k)
                    {
                        acc += a[base_addr_a + k + row * K] * b[base_addr_b + col + k * N];
                    }
 
                    // Finalize the result: alpha * A * B + beta * C
                    dst[base_addr_c + col + row * N] = alpha * acc + beta * c[base_addr_c + col + row * N];
                }
            }
        }
    }
 
    return dst;
}

References arm_compute::test::validation::b, SimpleTensor< T >::data_type(), arm_compute::test::validation::dst, K, M, N, SimpleTensor< T >::shape(), and arm_compute::test::validation::w.

Referenced by gemm_accumulate().

gemm_accumulate() [1/3]

template void arm_compute::test::validation::reference::gemm_accumulate	(	const SimpleTensor< float > &	a,
		const SimpleTensor< float > &	b,
		const SimpleTensor< float > &	c,
		float	alpha,
		float	beta,
		SimpleTensor< float > &	dst
	)

gemm_accumulate() [2/3]

template void arm_compute::test::validation::reference::gemm_accumulate	(	const SimpleTensor< half > &	a,
		const SimpleTensor< half > &	b,
		const SimpleTensor< half > &	c,
		float	alpha,
		float	beta,
		SimpleTensor< half > &	dst
	)

gemm_accumulate() [3/3]

void gemm_accumulate	(	const SimpleTensor< T > &	a,
		const SimpleTensor< T > &	b,
		const SimpleTensor< T > &	c,
		float	alpha,
		float	beta,
		SimpleTensor< T > &	dst
	)

Definition at line 185 of file GEMM.cpp.

{
    // Compute reference
    SimpleTensor<T> dst_gemm = gemm(a, b, c, alpha, beta);
    reference::arithmetic_operation<T>(reference::ArithmeticOperation::ADD, dst, dst_gemm, dst, ConvertPolicy::SATURATE);
}

References ADD, arm_compute::test::validation::b, arm_compute::test::validation::dst, gemm(), and arm_compute::SATURATE.

gemm_interleave_4x4()

SimpleTensor<T> arm_compute::test::validation::reference::gemm_interleave_4x4	(	const SimpleTensor< T > &	in,
		SimpleTensor< T > &	out
	)

Definition at line 37 of file GEMMInterleave4x4.h.

{
    const T      *mtx_in     = reinterpret_cast<const T *>(in.data());
    T            *mtx_ref    = reinterpret_cast<T *>(out.data());
    const int32_t in_rows    = in.shape().y();
    const int32_t in_cols    = in.shape().x();
    const int32_t out_stride = out.shape().x();
    int32_t       y          = 0;
    for(; y <= (in_rows - 4); y += 4)
    {
        const T *in_ptr = &mtx_in[y * in_cols];
 
        for(int32_t x = 0; x < in_cols; x++)
        {
            const T tmp[4] = { in_ptr[x + 0 * in_cols],
                               in_ptr[x + 1 * in_cols],
                               in_ptr[x + 2 * in_cols],
                               in_ptr[x + 3 * in_cols]
                             };
 
            T *dst = &mtx_ref[static_cast<size_t>(x * 4.f) + static_cast<size_t>(std::ceil(y / 4.f)) * out_stride];
            memcpy(dst, tmp, sizeof(T) * 4);
        }
    }
 
    // Leftover along the Y direction
    const int32_t leftover_y = in_rows - y;
 
    if(leftover_y != 0)
    {
        const T *in_ptr = &mtx_in[y * in_cols];
 
        for(int32_t x = 0; x < in_cols; x++)
        {
            T tmp[4] = { 0, 0, 0, 0 };
 
            for(int32_t k = 0; k < leftover_y; k++)
            {
                tmp[k] = in_ptr[k * in_cols + x];
            }
            T *dst = &mtx_ref[static_cast<size_t>(x * 4.f) + static_cast<size_t>(std::ceil(y / 4.f)) * out_stride];
            memcpy(dst, tmp, sizeof(T) * 4);
        }
    }
 
    return out;
}

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

gemm_interleave_blocked() [1/2]

SimpleTensor<T> arm_compute::test::validation::reference::gemm_interleave_blocked	(	const SimpleTensor< T > &	in,
		SimpleTensor< T > &	out,
		int	int_by,
		int	block,
		bool	transposed
	)

Definition at line 50 of file GEMMInterleaveBlocked.h.

{
    const int M = out.shape().y();
    const int N = out.shape().x();
    for(int y = 0; y < M; y++)
    {
        T *out_ptr = &out[y * N];
        for(int x = 0; x < (N / int_by); x += block)
        {
            for(int z = 0; z < int_by; z++)
            {
                for(int a = 0; (out_ptr <= &out[y * N + (N - 1)]) && a < block; a++)
                {
                    if(!transposed)
                        *out_ptr++ = safe_read(in, (y * int_by) + z, x + a);
                    else
                    {
                        const T value = safe_read(in, x + a, (y * int_by) + z);
                        *out_ptr++    = value;
                    }
                }
            }
        }
    }
    return out;
}

References M, N, safe_read(), and SimpleTensor< T >::shape().

gemm_interleave_blocked() [2/2]

template SimpleTensor<uint8_t> arm_compute::test::validation::reference::gemm_interleave_blocked	(	const SimpleTensor< uint8_t > &	in,
		SimpleTensor< uint8_t > &	out,
		int	int_by,
		int	block,
		bool	transposed
	)

gemm_mixed_precision() [1/2]

template SimpleTensor<half> arm_compute::test::validation::reference::gemm_mixed_precision	(	const SimpleTensor< half > &	a,
		const SimpleTensor< half > &	b,
		const SimpleTensor< half > &	c,
		float	alpha,
		float	beta
	)

gemm_mixed_precision() [2/2]

SimpleTensor< T > gemm_mixed_precision	(	const SimpleTensor< T > &	a,
		const SimpleTensor< T > &	b,
		const SimpleTensor< T > &	c,
		float	alpha,
		float	beta
	)

Definition at line 111 of file GEMM.cpp.

{
    // GEMM mixed-precision combines F32 accumulators with F16 multiplications
    // Create reference
    SimpleTensor<T> dst{c.shape(), c.data_type(), 1};
 
    // Compute reference
    const int M = a.shape().y();
    const int N = b.shape().x();
    const int K = a.shape().x();
    const int D = a.shape().z(); // Number of matrices in a batch
    const int W = a.shape()[3];  // Number of batched-gemm (Winograd case)
 
    const int a_stride_z = K * M;
    const int a_stride_w = K * M * D;
 
    const int b_stride_z =
        b.shape().num_dimensions() > 2
        ? N * K
        : 0; // Do not slide the matrix B along the 3th dimension in case matrix B has less than 3 dimensions
    int b_stride_w =
        b.shape().num_dimensions() > 3
        ? K * N * D
        : 0; // Do not slide the matrix B along the 4th dimension in case matrix B has less than 4 dimensions
 
    // Note: There are 3 gemm types: batched-gemm, multi-gemm, and batched of multi-gemms. The third dimension of tensor b is overloaded when tensor b has exactly 3 dimensions:
    // it can be either number of batches or multis. Batched-GEMM computation is detected only when the third dimension of "a" and "c" tensors is 1 and the number of dimensions is 4
    const bool is_batched_gemm = b.shape().num_dimensions() == 3 && a.shape().num_dimensions() == 4 &&
                                 c.shape().num_dimensions() == 4 && a.shape()[2] == 1 && c.shape()[2] == 1;
 
    // Batched-GEMM
    if (is_batched_gemm)
    {
        b_stride_w = b_stride_z;
    }
 
    const int c_stride_z = N * M;
    const int c_stride_w = N * M * D;
 
#if defined(_OPENMP) && !(defined(__arm__) && defined(__ANDROID__))
    #pragma omp parallel for collapse(2)
#endif /* _OPENMP */
    for (int w = 0; w < W; ++w)
    {
        for (int depth = 0; depth < D; ++depth)
        {
            const int base_addr_a = depth * a_stride_z + w * a_stride_w;
            const int base_addr_b = depth * b_stride_z + w * b_stride_w;
            const int base_addr_c = depth * c_stride_z + w * c_stride_w;
 
            for (int row = 0; row < M; ++row)
            {
                for (int col = 0; col < N; ++col)
                {
                    float acc(0);
 
                    for (int k = 0; k < K; ++k)
                    {
                        acc += static_cast<float>(a[base_addr_a + k + row * K] * b[base_addr_b + col + k * N]);
                    }
 
                    // Finalize the result: alpha * A * B + beta * C
                    dst[base_addr_c + col + row * N] =
                        static_cast<T>(alpha * acc + beta * c[base_addr_c + col + row * N]);
                }
            }
        }
    }
 
    return dst;
}

References arm_compute::test::validation::b, SimpleTensor< T >::data_type(), arm_compute::test::validation::dst, K, M, N, SimpleTensor< T >::shape(), and arm_compute::test::validation::w.

gemm_reshape_lhs_matrix() [1/4]

template SimpleTensor<char> arm_compute::test::validation::reference::gemm_reshape_lhs_matrix	(	const SimpleTensor< char > &	in,
		const TensorShape &	output_shape,
		const GEMMLHSMatrixInfo &	lhs_info
	)

gemm_reshape_lhs_matrix() [2/4]

template SimpleTensor<int> arm_compute::test::validation::reference::gemm_reshape_lhs_matrix	(	const SimpleTensor< int > &	in,
		const TensorShape &	output_shape,
		const GEMMLHSMatrixInfo &	lhs_info
	)

gemm_reshape_lhs_matrix() [3/4]

template SimpleTensor<short> arm_compute::test::validation::reference::gemm_reshape_lhs_matrix	(	const SimpleTensor< short > &	in,
		const TensorShape &	output_shape,
		const GEMMLHSMatrixInfo &	lhs_info
	)

gemm_reshape_lhs_matrix() [4/4]

SimpleTensor< T > gemm_reshape_lhs_matrix	(	const SimpleTensor< T > &	in,
		const TensorShape &	output_shape,
		const GEMMLHSMatrixInfo &	lhs_info
	)

Definition at line 43 of file GEMMReshapeLHSMatrix.cpp.

{
    ARM_COMPUTE_ERROR_ON(in.shape().num_dimensions() > 3);
 
    SimpleTensor<T> out{ output_shape, in.data_type() };
 
    // Initialize the output tensor with zero
    std::memset(&out[0], 0, out.num_elements() * sizeof(T));
 
    const unsigned int K = in.shape()[0];
    const unsigned int M = in.shape()[1];
    const unsigned int B = in.shape()[2];
 
    const unsigned int num_tiles_x = std::ceil(K / static_cast<float>(lhs_info.k0));
    const unsigned int num_tiles_y = std::ceil(M / static_cast<float>(lhs_info.m0));
 
    const TensorShape tile_dims(lhs_info.k0, lhs_info.m0);
    const TensorShape tile_dims_transposed(lhs_info.m0, lhs_info.k0);
 
    // Simple tensor for the input tile
    SimpleTensor<T> src_tile{ tile_dims, in.data_type() };
 
    // Simple tensor for the input tile
    SimpleTensor<T> src_tile_transposed{ tile_dims_transposed, in.data_type() };
 
    // Simple tensor to use when storing the values
    SimpleTensor<T> *tile_to_use = lhs_info.transpose ? &src_tile_transposed : &src_tile;
 
    const unsigned int offset_output_x = lhs_info.interleave ? tile_to_use->shape()[0] : tile_to_use->shape()[0] * tile_to_use->shape()[1];
    const unsigned int step_output_x   = lhs_info.interleave ? tile_to_use->shape()[0] * lhs_info.v0 : tile_to_use->shape()[0];
 
    for(unsigned int z = 0; z < B; ++z)
    {
        for(unsigned int y = 0; y < num_tiles_y; ++y)
        {
            for(unsigned int x = 0; x < num_tiles_x; ++x)
            {
                // Get the tile from the input tensor
                get_tile<T>(in, src_tile, Coordinates(x * lhs_info.k0, y * lhs_info.m0, z, 0));
 
                if(lhs_info.transpose)
                {
                    // Transpose matrix
                    transpose_matrix<T>(src_tile, src_tile_transposed);
                }
 
                // Store
                const unsigned int offset_output = (x * lhs_info.k0 * lhs_info.m0 * lhs_info.v0) + ((y % lhs_info.v0) * offset_output_x) + ((y / lhs_info.v0) * out.shape()[0]) + (z * out.shape()[0] * out.shape()[1]);
 
                for(unsigned int i = 0; i < tile_to_use->shape()[1]; ++i)
                {
                    const unsigned int offset_tile = i * tile_to_use->shape()[0];
 
                    // Copy per row
                    std::copy(&(*tile_to_use)[offset_tile], &(*tile_to_use)[offset_tile + tile_to_use->shape()[0]], &out[offset_output + i * step_output_x]);
                }
            }
        }
    }
 
    return out;
}

References ARM_COMPUTE_ERROR_ON, arm_compute::B, copy(), SimpleTensor< T >::data_type(), GEMMLHSMatrixInfo::interleave, K, GEMMLHSMatrixInfo::k0, M, GEMMLHSMatrixInfo::m0, arm_compute::test::validation::output_shape, SimpleTensor< T >::shape(), GEMMLHSMatrixInfo::transpose, and GEMMLHSMatrixInfo::v0.

gemm_reshape_rhs_matrix() [1/4]

template SimpleTensor<char> arm_compute::test::validation::reference::gemm_reshape_rhs_matrix	(	const SimpleTensor< char > &	in,
		const TensorShape &	output_shape,
		const GEMMRHSMatrixInfo &	rhs_info
	)

gemm_reshape_rhs_matrix() [2/4]

template SimpleTensor<int> arm_compute::test::validation::reference::gemm_reshape_rhs_matrix	(	const SimpleTensor< int > &	in,
		const TensorShape &	output_shape,
		const GEMMRHSMatrixInfo &	rhs_info
	)

gemm_reshape_rhs_matrix() [3/4]

template SimpleTensor<short> arm_compute::test::validation::reference::gemm_reshape_rhs_matrix	(	const SimpleTensor< short > &	in,
		const TensorShape &	output_shape,
		const GEMMRHSMatrixInfo &	rhs_info
	)

gemm_reshape_rhs_matrix() [4/4]

SimpleTensor< T > gemm_reshape_rhs_matrix	(	const SimpleTensor< T > &	in,
		const TensorShape &	output_shape,
		const GEMMRHSMatrixInfo &	rhs_info
	)

Definition at line 43 of file GEMMReshapeRHSMatrix.cpp.

{
    ARM_COMPUTE_ERROR_ON(in.shape().num_dimensions() > 3);
 
    SimpleTensor<T> out{ output_shape, in.data_type() };
 
    // Initialize the output tensor with zero
    std::memset(&out[0], 0, out.num_elements() * sizeof(T));
 
    const unsigned int N = in.shape()[0];
    const unsigned int K = in.shape()[1];
    const unsigned int B = in.shape()[2];
 
    const unsigned int num_tiles_x = std::ceil(N / static_cast<float>(rhs_info.n0));
    const unsigned int num_tiles_y = std::ceil(K / static_cast<float>(rhs_info.k0));
 
    const TensorShape tile_dims(rhs_info.n0, rhs_info.k0);
    const TensorShape tile_dims_transposed(rhs_info.k0, rhs_info.n0);
 
    // Simple tensor for the input tile
    SimpleTensor<T> src_tile{ tile_dims, in.data_type() };
 
    // Simple tensor for the input tile
    SimpleTensor<T> src_tile_transposed{ tile_dims_transposed, in.data_type() };
 
    // Simple tensor to use when storing the values
    SimpleTensor<T> *tile_to_use = rhs_info.transpose ? &src_tile_transposed : &src_tile;
 
    const unsigned int offset_output_x = rhs_info.interleave ? tile_to_use->shape()[0] : tile_to_use->shape()[0] * tile_to_use->shape()[1];
    const unsigned int step_output_x   = rhs_info.interleave ? tile_to_use->shape()[0] * rhs_info.h0 : tile_to_use->shape()[0];
#ifdef ARM_COMPUTE_OPENMP
    #pragma omp parallel for schedule(dynamic, 1) collapse(3)
#endif /* _OPENMP */
    for(unsigned int z = 0; z < B; ++z)
    {
        for(unsigned int y = 0; y < num_tiles_y; ++y)
        {
            for(unsigned int x = 0; x < num_tiles_x; ++x)
            {
                // Get the tile from the input tensor
                get_tile<T>(in, src_tile, Coordinates(x * rhs_info.n0, y * rhs_info.k0, z, 0));
 
                if(rhs_info.transpose)
                {
                    // Transpose matrix
                    transpose_matrix<T>(src_tile, src_tile_transposed);
                }
 
                // Store
                const unsigned int offset_output = (y * rhs_info.k0 * rhs_info.n0 * rhs_info.h0) + ((x % rhs_info.h0) * offset_output_x) + ((x / rhs_info.h0) * out.shape()[0]) + (z * out.shape()[0] * out.shape()[1]);
 
                for(unsigned int i = 0; i < tile_to_use->shape()[1]; ++i)
                {
                    const unsigned int offset_tile = i * tile_to_use->shape()[0];
 
                    // Copy per row
                    std::copy(&(*tile_to_use)[offset_tile], &(*tile_to_use)[offset_tile + tile_to_use->shape()[0]], &out[offset_output + i * step_output_x]);
                }
            }
        }
    }
 
    return out;
}

References ARM_COMPUTE_ERROR_ON, arm_compute::B, copy(), SimpleTensor< T >::data_type(), GEMMRHSMatrixInfo::h0, GEMMRHSMatrixInfo::interleave, K, GEMMRHSMatrixInfo::k0, N, GEMMRHSMatrixInfo::n0, arm_compute::test::validation::output_shape, SimpleTensor< T >::shape(), and GEMMRHSMatrixInfo::transpose.

gemm_transpose_1xW()

SimpleTensor<T> arm_compute::test::validation::reference::gemm_transpose_1xW

(

const SimpleTensor< T > &

in

)

Definition at line 37 of file GEMMTranspose1xW.h.

{
    const int         W = 16 / sizeof(T);
    const TensorShape shape_out(static_cast<size_t>(in.shape().y() * W), static_cast<size_t>(std::ceil(in.shape().x() / static_cast<float>(W))));
    SimpleTensor<T>   out(shape_out, in.data_type());
    const int32_t     in_height     = in.shape().y();
    const int32_t     in_width      = in.shape().x();
    const int32_t     out_width     = out.shape().x();
    const T          *in_base_addr  = reinterpret_cast<const T *>(in.data());
    T                *out_base_addr = reinterpret_cast<T *>(out.data());
    int               x             = 0;
    for(; x < in_width; x += W)
    {
        for(int y = 0; y < in_height; y++)
        {
            const T *in_addr  = (in_base_addr + x + y * in_width);
            T       *out_addr = (out_base_addr + y * W + (x / W) * out_width);
 
            for(int k = 0; k < W; ++k)
            {
                // If the input width is not multiple of W, we fill the reference with 0s
                if((x + k) >= in_width)
                {
                    out_addr[k] = T(0);
                }
                else
                {
                    out_addr[k] = in_addr[k];
                }
            }
        }
    }
    return out;
}

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

gemmlowp()

SimpleTensor< T1 > gemmlowp	(	const SimpleTensor< T2 > &	a,
		const SimpleTensor< T3 > &	b,
		TensorShape	shape_c
	)

Definition at line 243 of file GEMMLowp.cpp.

{
    return gemmlowp_matrix_multiply_core<T1, T2, T3>(a, b, shape_c, 0, 0);
}

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

gemmlowp< int32_t, int8_t, int8_t >()

template SimpleTensor<int32_t> arm_compute::test::validation::reference::gemmlowp< int32_t, int8_t, int8_t >	(	const SimpleTensor< int8_t > &	a,
		const SimpleTensor< int8_t > &	b,
		TensorShape	shape_c
	)

gemmlowp< int32_t, uint8_t, int8_t >()

template SimpleTensor<int32_t> arm_compute::test::validation::reference::gemmlowp< int32_t, uint8_t, int8_t >	(	const SimpleTensor< uint8_t > &	a,
		const SimpleTensor< int8_t > &	b,
		TensorShape	shape_c
	)

gemmlowp< int32_t, uint8_t, uint8_t >()

template SimpleTensor<int32_t> arm_compute::test::validation::reference::gemmlowp< int32_t, uint8_t, uint8_t >	(	const SimpleTensor< uint8_t > &	a,
		const SimpleTensor< uint8_t > &	b,
		TensorShape	shape_c
	)

gemmlowp_matrix_multiply_core() [1/4]

template SimpleTensor<int32_t> arm_compute::test::validation::reference::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
	)

gemmlowp_matrix_multiply_core() [2/4]

SimpleTensor<T1> arm_compute::test::validation::reference::gemmlowp_matrix_multiply_core	(	const SimpleTensor< T2 > &	a,
		const SimpleTensor< T3 > &	b,
		TensorShape	shape_c,
		int32_t	a_offset,
		int32_t	b_offset
	)

gemmlowp_matrix_multiply_core() [3/4]

SimpleTensor<T_out> arm_compute::test::validation::reference::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
	)

Definition at line 182 of file GEMMLowp.cpp.

{
    static_assert(std::is_same<typename std::decay<T_out>::type, int32_t>::value, "Only int32_t is allowed for the output");
 
    DataType            dt = std::is_same<T_out, int32_t>::value ? DataType::S32 : DataType::U32;
    SimpleTensor<T_out> c(shape_c, dt);
 
    const int K = a.shape().x();
    const int M = a.shape().y();
    const int N = b.shape().x();
    const int D = a.shape().z(); // Number of matrices in a batch
 
    const int a_stride_z = K * M;
    // Do not slide the matrix B along the 3rd dimension in case matrix B has less than 3 dimensions
    const int b_stride_z = b.shape().num_dimensions() > 2 ? N * K : 0;
    const int c_stride_z = N * M;
 
    std::vector<T_out> acc;
    acc.resize(N);
 
    for(int depth = 0; depth < D; ++depth)
    {
        const int base_addr_a = depth * a_stride_z;
        const int base_addr_b = depth * b_stride_z;
        const int base_addr_c = depth * c_stride_z;
 
        for(int i = 0; i < M; ++i)
        {
            for(int j = 0; j < N; ++j)
            {
                acc[j] = 0;
            }
            for(int k = 0; k < K; ++k)
            {
                const T_out tmp_a = a_offset + static_cast<T_out>(a[base_addr_a + k + i * K]);
                for(int j = 0; j < N; ++j)
                {
                    const T_out tmp_b       = b_offset + static_cast<T_out>(b[base_addr_b + j + k * N]);
                    const T_out mult_as_int = tmp_a * tmp_b;
                    acc[j] += mult_as_int;
                }
            }
            for(int j = 0; j < N; ++j)
            {
                c[base_addr_c + j + i * N] = acc[j];
            }
        }
    }
 
    return c;
}

References arm_compute::test::validation::b, dt, K, M, N, arm_compute::S32, SimpleTensor< T >::shape(), type, and arm_compute::U32.

gemmlowp_matrix_multiply_core() [4/4]

template SimpleTensor<int32_t> arm_compute::test::validation::reference::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
	)

gemmlowp_matrix_multiply_core_accumulate() [1/4]

template void arm_compute::test::validation::reference::gemmlowp_matrix_multiply_core_accumulate	(	const SimpleTensor< int8_t > &	a,
		const SimpleTensor< int8_t > &	b,
		TensorShape	shape_c,
		int32_t	a_offset,
		int32_t	b_offset,
		SimpleTensor< int32_t > &	dst
	)

gemmlowp_matrix_multiply_core_accumulate() [2/4]

void arm_compute::test::validation::reference::gemmlowp_matrix_multiply_core_accumulate	(	const SimpleTensor< T2 > &	a,
		const SimpleTensor< T3 > &	b,
		TensorShape	shape_c,
		int32_t	a_offset,
		int32_t	b_offset,
		SimpleTensor< T1 > &	dst_
	)

gemmlowp_matrix_multiply_core_accumulate() [3/4]

void arm_compute::test::validation::reference::gemmlowp_matrix_multiply_core_accumulate	(	const SimpleTensor< T_in > &	a,
		const SimpleTensor< T_in_1 > &	b,
		TensorShape	shape_c,
		int32_t	a_offset,
		int32_t	b_offset,
		SimpleTensor< T_out > &	dst
	)

Definition at line 235 of file GEMMLowp.cpp.

{
    SimpleTensor<T_out> dst_gemm = gemmlowp_matrix_multiply_core<T_out, T_in, T_in_1>(a, b, shape_c, a_offset, b_offset);
    reference::arithmetic_operation<T_out>(reference::ArithmeticOperation::ADD, dst, dst_gemm, dst, ConvertPolicy::SATURATE);
}

References ADD, arm_compute::test::validation::b, arm_compute::test::validation::dst, and arm_compute::SATURATE.

gemmlowp_matrix_multiply_core_accumulate() [4/4]

template void arm_compute::test::validation::reference::gemmlowp_matrix_multiply_core_accumulate	(	const SimpleTensor< uint8_t > &	a,
		const SimpleTensor< uint8_t > &	b,
		TensorShape	shape_c,
		int32_t	a_offset,
		int32_t	b_offset,
		SimpleTensor< int32_t > &	dst
	)

gemmlowp_quantize_down_scale() [1/5]

template SimpleTensor< int8_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
	)

gemmlowp_quantize_down_scale() [2/5]

template SimpleTensor< int8_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
	)

gemmlowp_quantize_down_scale() [3/5]

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
	)

Definition at line 260 of file GEMMLowp.cpp.

{
    SimpleTensor<TOut> dst(in.shape(), DataTypeExtractor<TOut>::data_type());
 
    quantize_down_scale<TIn, TOut>(&in, &bias, &dst, result_offset, result_mult_int, result_shift, min, max);
 
    return dst;
}

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

gemmlowp_quantize_down_scale() [4/5]

SimpleTensor<uint8_t> arm_compute::test::validation::reference::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
	)

gemmlowp_quantize_down_scale() [5/5]

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
	)

Definition at line 249 of file GEMMLowp.cpp.

{
    SimpleTensor<TOut> dst(in.shape(), DataTypeExtractor<TOut>::data_type());
 
    quantize_down_scale<TIn, TOut>(&in, nullptr, &dst, result_offset, result_mult_int, result_shift, min, max);
 
    return dst;
}

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

gemmlowp_quantize_down_scale_by_fixedpoint() [1/4]

template SimpleTensor< int16_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
	)

gemmlowp_quantize_down_scale_by_fixedpoint() [2/4]

template SimpleTensor< int16_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
	)

gemmlowp_quantize_down_scale_by_fixedpoint() [3/4]

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
	)

Definition at line 282 of file GEMMLowp.cpp.

{
    SimpleTensor<TOut> dst(in.shape(), DataTypeExtractor<TOut>::data_type());
 
    quantize_down_scale_by_fixedpoint<TIn, TOut>(&in, &bias, &dst, result_fixedpoint_multiplier, result_shift, result_offset_after_shift, min, max);
 
    return dst;
}

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

gemmlowp_quantize_down_scale_by_fixedpoint() [4/4]

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
	)

Definition at line 271 of file GEMMLowp.cpp.

{
    SimpleTensor<TOut> dst(in.shape(), DataTypeExtractor<TOut>::data_type());
 
    quantize_down_scale_by_fixedpoint<TIn, TOut>(&in, nullptr, &dst, result_fixedpoint_multiplier, result_shift, result_offset_after_shift, min, max);
 
    return dst;
}

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

gemmlowp_quantize_down_scale_by_float() [1/4]

template SimpleTensor< int8_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
	)

gemmlowp_quantize_down_scale_by_float() [2/4]

template SimpleTensor< int8_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
	)

gemmlowp_quantize_down_scale_by_float() [3/4]

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
	)

Definition at line 293 of file GEMMLowp.cpp.

{
    SimpleTensor<TOut> dst(in.shape(), DataTypeExtractor<TOut>::data_type());
 
    quantize_down_scale_by_float<TIn, TOut>(&in, &bias, &dst, result_real_multiplier, result_offset, min, max);
 
    return dst;
}

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

gemmlowp_quantize_down_scale_by_float() [4/4]

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
	)

Definition at line 304 of file GEMMLowp.cpp.

{
    SimpleTensor<TOut> dst(in.shape(), DataTypeExtractor<TOut>::data_type());
 
    quantize_down_scale_by_float<TIn, TOut>(&in, nullptr, &dst, result_real_multiplier, result_offset, min, max);
 
    return dst;
}

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

im2col() [1/4]

template void arm_compute::test::validation::reference::im2col	(	const SimpleTensor< float > &	src,
		SimpleTensor< float > &	dst,
		const Size2D &	kernel_dims,
		const PadStrideInfo &	conv_info,
		bool	has_bias,
		unsigned int	num_groups
	)

im2col() [2/4]

template void arm_compute::test::validation::reference::im2col	(	const SimpleTensor< half > &	src,
		SimpleTensor< half > &	dst,
		const Size2D &	kernel_dims,
		const PadStrideInfo &	conv_info,
		bool	has_bias,
		unsigned int	num_groups
	)

im2col() [3/4]

void im2col	(	const SimpleTensor< T > &	src,
		SimpleTensor< T > &	dst,
		const Size2D &	kernel_dims,
		const PadStrideInfo &	conv_info,
		bool	has_bias,
		unsigned int	num_groups
	)

Definition at line 144 of file Im2Col.cpp.

{
    switch(src.data_layout())
    {
        case DataLayout::NCHW:
        {
            im2col_nchw(src, dst, kernel_dims, conv_info, has_bias, num_groups);
            break;
        }
        case DataLayout::NHWC:
        {
            im2col_nhwc(src, dst, kernel_dims, conv_info, has_bias);
            break;
        }
        default:
        {
            ARM_COMPUTE_ERROR("Not supported.");
            break;
        }
    }
}

References ARM_COMPUTE_ERROR, arm_compute::test::validation::conv_info, arm_compute::test::validation::dst, arm_compute::test::validation::has_bias, im2col_nchw(), im2col_nhwc(), arm_compute::NCHW, arm_compute::NHWC, arm_compute::test::validation::num_groups, and arm_compute::test::validation::src.

im2col() [4/4]

template void arm_compute::test::validation::reference::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
	)

im2col_nchw()

void arm_compute::test::validation::reference::im2col_nchw	(	const SimpleTensor< T > &	src,
		SimpleTensor< T > &	dst,
		const Size2D &	kernel_dims,
		const PadStrideInfo &	conv_info,
		bool	has_bias,
		unsigned int	num_groups
	)

Definition at line 39 of file Im2Col.cpp.

{
    ARM_COMPUTE_ERROR_ON(src.data_layout() != DataLayout::NCHW);
    const int stride_x      = conv_info.stride().first;
    const int stride_y      = conv_info.stride().second;
    const int kernel_width  = kernel_dims.width;
    const int kernel_height = kernel_dims.height;
    const int pad_x         = conv_info.pad().first;
    const int pad_y         = conv_info.pad().second;
    const int src_width     = src.shape().x();
    const int src_height    = src.shape().y();
    const int src_channels  = src.shape().z();
    const int batches       = src.shape().total_size_upper(3);
    const int dst_height    = dst.shape().y();
    const int pad_val       = is_data_type_quantized_asymmetric(src.data_type()) ? src.quantization_info().uniform().offset : 0;
    int       dst_idx       = 0;
 
    // Compute width and height of the convolved tensors
    std::pair<unsigned int, unsigned int> convolved_dims = scaled_dimensions(src_width, src_height, kernel_dims.width, kernel_dims.height, conv_info);
 
    for(int b = 0; b < batches; ++b)
    {
        for(int g = 0; g < static_cast<int>(num_groups); ++g)
        {
            const int first_group_ch = g * (src_channels / num_groups);
            const int last_group_ch  = (g + 1) * (src_channels / num_groups);
 
            for(int yo = 0; yo < dst_height; ++yo)
            {
                // Compute input spatial coordinates
                const int xi = (yo % convolved_dims.first) * stride_x;
                const int yi = (yo / convolved_dims.first) * stride_y;
 
                for(int ci = first_group_ch; ci < last_group_ch; ++ci)
                {
                    for(int yk = 0; yk < kernel_height; ++yk)
                    {
                        for(int xk = 0; xk < kernel_width; ++xk)
                        {
                            dst[dst_idx++] = tensor_elem_at(src, Coordinates(xi + xk - pad_x, yi + yk - pad_y, ci, b), BorderMode::CONSTANT, static_cast<T>(pad_val));
                        }
                    }
                }
 
                if(has_bias)
                {
                    dst[dst_idx++] = static_cast<T>(1);
                }
            }
        }
    }
}

References ARM_COMPUTE_ERROR_ON, arm_compute::test::validation::b, batches, ci, arm_compute::CONSTANT, arm_compute::test::validation::conv_info, arm_compute::test::validation::dst, arm_compute::test::validation::has_bias, Size2D::height, arm_compute::is_data_type_quantized_asymmetric(), arm_compute::NCHW, arm_compute::test::validation::num_groups, arm_compute::scaled_dimensions(), arm_compute::test::validation::src, arm_compute::test::validation::tensor_elem_at(), and Size2D::width.

Referenced by im2col().

im2col_nhwc()

void arm_compute::test::validation::reference::im2col_nhwc	(	const SimpleTensor< T > &	src,
		SimpleTensor< T > &	dst,
		const Size2D &	kernel_dims,
		const PadStrideInfo &	conv_info,
		bool	has_bias
	)

Definition at line 93 of file Im2Col.cpp.

{
    ARM_COMPUTE_ERROR_ON(src.data_layout() != DataLayout::NHWC);
    const int stride_x      = conv_info.stride().first;
    const int stride_y      = conv_info.stride().second;
    const int kernel_width  = kernel_dims.width;
    const int kernel_height = kernel_dims.height;
    const int pad_x         = conv_info.pad().first;
    const int pad_y         = conv_info.pad().second;
    const int src_width     = src.shape().y();
    const int src_height    = src.shape().z();
    const int src_channels  = src.shape().x();
    const int batches       = src.shape().total_size_upper(3);
    const int dst_width     = has_bias ? dst.shape().x() - 1 : dst.shape().x();
    const int dst_height    = dst.shape().y();
    const int pad_val       = is_data_type_quantized_asymmetric(src.data_type()) ? src.quantization_info().uniform().offset : 0;
 
    // Compute width and height of the convolved tensors
    std::pair<unsigned int, unsigned int> convolved_dims = scaled_dimensions(src_width, src_height, kernel_dims.width, kernel_dims.height, conv_info);
#if defined(_OPENMP)
    #pragma omp parallel for schedule(dynamic, 1) collapse(2)
#endif /* _OPENMP */
    for(int b = 0; b < batches; ++b)
    {
        for(int yo = 0; yo < dst_height; ++yo)
        {
            // Compute input spatial coordinates
            const int xi = (yo % convolved_dims.first) * stride_x;
            const int yi = (yo / convolved_dims.first) * stride_y;
 
            for(int ci = 0; ci < src_channels; ++ci)
            {
                for(int yk = 0; yk < kernel_height; ++yk)
                {
                    for(int xk = 0; xk < kernel_width; ++xk)
                    {
                        dst[ci + (xk + yk * kernel_width) * src_channels + yo * dst.shape().x() + b * dst.shape().x() * dst.shape().y()] = tensor_elem_at(src, Coordinates(ci, xi + xk - pad_x, yi + yk - pad_y, b),
                                                                                                                                           BorderMode::CONSTANT, static_cast<T>(pad_val));
                    }
                }
            }
 
            if(has_bias)
            {
                dst[dst_width + yo * dst.shape().x() + b * dst.shape().x() * dst.shape().y()] = static_cast<T>(1);
            }
        }
    }
}

References ARM_COMPUTE_ERROR_ON, arm_compute::test::validation::b, batches, ci, arm_compute::CONSTANT, arm_compute::test::validation::conv_info, arm_compute::test::validation::dst, arm_compute::test::validation::has_bias, Size2D::height, arm_compute::is_data_type_quantized_asymmetric(), arm_compute::NHWC, arm_compute::scaled_dimensions(), arm_compute::test::validation::src, arm_compute::test::validation::tensor_elem_at(), and Size2D::width.

Referenced by im2col().

indirect_conv2d_addr_precalculation()

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
	)

Definition at line 38 of file IndirectConv2dAddressPrecalculation.cpp.

{
    SimpleTensor<int32_t> out{ shape_dst, DataType::S32 };
 
    constexpr unsigned int width_idx = 1;
    constexpr unsigned int heigh_idx = 2;
 
    const int src_conv_width  = static_cast<int32_t>(shape_conv_src[width_idx]); // NHWC
    const int src_conv_height = static_cast<int32_t>(shape_conv_src[heigh_idx]); // NHWC
    const int dst_conv_width  = static_cast<int32_t>(shape_conv_dst[width_idx]); // NHWC
    const int wei_conv_width  = static_cast<int32_t>(shape_conv_wei[width_idx]); // NHWC
    const int wei_conv_height = static_cast<int32_t>(shape_conv_wei[heigh_idx]); // NHWC
    const int dst_width       = static_cast<int32_t>(shape_dst[0]);
    const int dst_height      = static_cast<int32_t>(shape_dst[1]);
    const int dst_batch       = static_cast<int32_t>(shape_dst[2]);
    const int ks              = wei_conv_width * wei_conv_height;
    const int stride_x        = static_cast<int32_t>(conv_info.stride().first);
    const int stride_y        = static_cast<int32_t>(conv_info.stride().second);
    const int pad_left        = static_cast<int32_t>(conv_info.pad_left());
    const int pad_top         = static_cast<int32_t>(conv_info.pad_top());
 
    const int m0 = dst_width / ks;
 
    for(int z = 0; z < dst_batch; ++z)
    {
        for(int y = 0; y < dst_height; ++y)
        {
            const int mout = y * m0;
            for(int ki = 0; ki < ks; ++ki)
            {
                const int xk = ki % wei_conv_width;
                const int yk = ki / wei_conv_width;
                for(int mi = 0; mi < m0; ++mi)
                {
                    int xi = ((mout + mi) % dst_conv_width) * stride_x;
                    int yi = ((mout + mi) / dst_conv_width) * stride_y;
                    xi -= pad_left;
                    yi -= pad_top;
                    const int x_s = xi + xk;
                    const int y_s = yi + yk;
                    int       my  = x_s + y_s * src_conv_width;
                    my            = my + z * src_conv_width * src_conv_height;
                    my            = x_s >= 0 ? my : -1;
                    my            = x_s < src_conv_width ? my : -1;
                    my            = y_s >= 0 ? my : -1;
                    my            = y_s < src_conv_height ? my : -1;
 
                    const unsigned int addr_out = mi + ki * m0 + y * (dst_width) + z * (dst_width * dst_height);
                    out[addr_out]               = my;
                }
            }
        }
    }
 
    return out;
}

References arm_compute::test::validation::conv_info, arm_compute::S32, and arm_compute::cpu::width_idx.

instance_normalization() [1/3]

template SimpleTensor<float> arm_compute::test::validation::reference::instance_normalization	(	const SimpleTensor< float > &	src,
		float	gamma,
		float	beta,
		float	epsilon
	)

instance_normalization() [2/3]

template SimpleTensor<half> arm_compute::test::validation::reference::instance_normalization	(	const SimpleTensor< half > &	src,
		float	gamma,
		float	beta,
		float	epsilon
	)

instance_normalization() [3/3]

SimpleTensor< T > instance_normalization	(	const SimpleTensor< T > &	src,
		float	gamma,
		float	beta,
		float	epsilon
	)

Definition at line 40 of file InstanceNormalizationLayer.cpp.

{
    SimpleTensor<T> dst{ src.shape(), src.data_type() };
 
    //NCHW
    const size_t w_size = src.shape()[0];
    const size_t h_size = src.shape()[1];
    const size_t c_size = src.shape()[2];
    const size_t n_size = src.shape()[3];
#if defined(_OPENMP)
    #pragma omp parallel for collapse(2)
#endif /* _OPENMP */
    for(size_t n_i = 0; n_i < n_size; ++n_i)
    {
        for(size_t c_i = 0; c_i < c_size; ++c_i)
        {
            float sum_h_w    = 0;
            float sum_sq_h_w = 0;
 
            for(size_t h_i = 0; h_i < h_size; ++h_i)
            {
                for(size_t w_i = 0; w_i < w_size; ++w_i)
                {
                    float val = src[coord2index(src.shape(), Coordinates(w_i, h_i, c_i, n_i))];
                    sum_h_w += val;
                    sum_sq_h_w += val * val;
                }
            }
            //Compute mean
            const float mean_h_w = sum_h_w / (h_size * w_size);
            //Compute variance
            const float var_h_w = sum_sq_h_w / (h_size * w_size) - mean_h_w * mean_h_w;
            ;
 
            //Apply mean
            for(size_t h_i = 0; h_i < h_size; ++h_i)
            {
                for(size_t w_i = 0; w_i < w_size; ++w_i)
                {
                    //Compute output
                    size_t index = coord2index(src.shape(), Coordinates(w_i, h_i, c_i, n_i));
                    dst[index]   = (src[index] - mean_h_w) * gamma / std::sqrt(var_h_w + epsilon) + beta;
                }
            }
        }
    }
    return dst;
}

References arm_compute::test::coord2index(), arm_compute::test::validation::dst, arm_compute::quantization::epsilon, and arm_compute::test::validation::src.

l2_normalize() [1/3]

template SimpleTensor<float> arm_compute::test::validation::reference::l2_normalize	(	const SimpleTensor< float > &	src,
		unsigned int	axis,
		float	epsilon
	)

l2_normalize() [2/3]

template SimpleTensor<half> arm_compute::test::validation::reference::l2_normalize	(	const SimpleTensor< half > &	src,
		unsigned int	axis,
		float	epsilon
	)

l2_normalize() [3/3]

SimpleTensor< T > l2_normalize	(	const SimpleTensor< T > &	src,
		unsigned int	axis,
		float	epsilon
	)

Definition at line 51 of file L2NormalizeLayer.cpp.

{
    // Create reference
    SimpleTensor<T> dst{ src.shape(), src.data_type() };
 
    // Reduce across given axis
    SimpleTensor<T> sum = reduction_operation<T, T>(src, get_output_shape(src.shape(), axis), axis, ReductionOperation::SUM_SQUARE);
 
    // Compute reference
    const int upper_dims     = src.shape().total_size_upper(axis + 1);
    const int lower_dims     = src.shape().total_size_lower(axis + 1);
    const int lower_dims_sum = sum.shape().total_size_lower(axis + 1);
 
    for(int du = 0; du < upper_dims; ++du)
    {
        const T *src_row_ptr = src.data() + du * lower_dims;
        T       *dst_row_ptr = dst.data() + du * lower_dims;
        switch(axis)
        {
            case 0:
            {
                const int elems               = src.shape()[0];
                const T   normalization_value = sqrt(std::max(sum[du], static_cast<T>(epsilon)));
                std::transform(src_row_ptr, src_row_ptr + elems, dst_row_ptr, [normalization_value](T val)
                {
                    return val / normalization_value;
                });
            }
            break;
            case 1:
            case 2:
            {
                for(int ld = 0; ld < lower_dims; ++ld)
                {
                    const T normalization_value = sqrt(std::max(sum[ld % lower_dims_sum + du * lower_dims_sum], static_cast<T>(epsilon)));
                    dst_row_ptr[ld]             = src_row_ptr[ld] / normalization_value;
                }
            }
            break;
            default:
                ARM_COMPUTE_ERROR("Axis not supported");
        }
    }
 
    return dst;
}

References ARM_COMPUTE_ERROR, arm_compute::test::validation::dst, arm_compute::quantization::epsilon, SimpleTensor< T >::shape(), arm_compute::test::validation::src, and arm_compute::SUM_SQUARE.

logical_and() [1/2]

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

Definition at line 108 of file Logical.cpp.

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

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

logical_and() [2/2]

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

logical_binary_op()

T arm_compute::test::validation::reference::logical_binary_op	(	arm_compute::LogicalOperation	op,
		T	src1,
		T	src2
	)

Definition at line 37 of file Logical.cpp.

{
    switch(op)
    {
        case arm_compute::LogicalOperation::And:
            return src1 && src2;
        case arm_compute::LogicalOperation::Or:
            return src1 || src2;
        // The following operators are either invalid or not binary operator
        case arm_compute::LogicalOperation::Not:
        // fall through
        case arm_compute::LogicalOperation::Unknown:
        // fall through
        default:
            ARM_COMPUTE_ASSERT(true);
    }
    return T{};
}

References arm_compute::And, ARM_COMPUTE_ASSERT, arm_compute::Not, arm_compute::Or, and arm_compute::Unknown.

logical_not() [1/2]

SimpleTensor< T > logical_not

(

const SimpleTensor< T > &

src

)

Definition at line 121 of file Logical.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.

logical_not() [2/2]

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

(

const SimpleTensor< uint8_t > &

src1

)

logical_or() [1/2]

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

Definition at line 95 of file Logical.cpp.

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

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

logical_or() [2/2]

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

max_unpooling_layer() [1/3]

template SimpleTensor<float> arm_compute::test::validation::reference::max_unpooling_layer	(	const SimpleTensor< float > &	src,
		const PoolingLayerInfo &	info,
		const QuantizationInfo &	output_qinfo,
		SimpleTensor< uint32_t > &	indices,
		TensorShape	output_shape,
		DataLayout	data_layout
	)

max_unpooling_layer() [2/3]

template SimpleTensor<half> arm_compute::test::validation::reference::max_unpooling_layer	(	const SimpleTensor< half > &	src,
		const PoolingLayerInfo &	info,
		const QuantizationInfo &	output_qinfo,
		SimpleTensor< uint32_t > &	indices,
		TensorShape	output_shape,
		DataLayout	data_layout
	)

max_unpooling_layer() [3/3]

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
	)

Definition at line 92 of file MaxUnpoolingLayer.cpp.

{
    return max_unpooling_layer_internal<T>(src, info, output_qinfo, indices, output_shape, data_layout);
}

References arm_compute::test::validation::data_layout, arm_compute::test::validation::info, arm_compute::test::validation::output_shape, and arm_compute::test::validation::src.

max_unpooling_layer< uint8_t >()

SimpleTensor<uint8_t> arm_compute::test::validation::reference::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
	)

Definition at line 79 of file MaxUnpoolingLayer.cpp.

{
    SimpleTensor<float>   src_tmp = convert_from_asymmetric(src);
    SimpleTensor<float>   dst_tmp = max_unpooling_layer_internal<float>(src_tmp, info, output_qinfo, indices, output_shape, data_layout);
    SimpleTensor<uint8_t> dst     = convert_to_asymmetric<uint8_t>(dst_tmp, output_qinfo);
    return dst;
}

References arm_compute::test::validation::convert_from_asymmetric(), arm_compute::test::validation::data_layout, arm_compute::test::validation::dst, arm_compute::test::validation::info, arm_compute::test::validation::output_shape, and arm_compute::test::validation::src.

max_unpooling_layer_internal()

SimpleTensor<T> arm_compute::test::validation::reference::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
	)

Definition at line 41 of file MaxUnpoolingLayer.cpp.

{
    ARM_COMPUTE_UNUSED(info);
    ARM_COMPUTE_UNUSED(output_qinfo);
    ARM_COMPUTE_UNUSED(data_layout);
    // Create reference
    SimpleTensor<T> dst{ output_shape, src.data_type(), 1 };
    ARM_COMPUTE_ERROR_ON(indices.shape().total_size() == 0);
    std::fill_n(dst.data(), dst.num_elements(), 0);
    const auto w_indices = static_cast<int>(indices.shape()[0]);
    const auto h_indices = static_cast<int>(indices.shape()[1]);
    const auto z_indices = static_cast<int>(indices.shape()[2]);
    const auto b_indices = static_cast<int>(indices.shape()[3]);
    const auto w_dst     = static_cast<int>(dst.shape()[0]);
    const auto h_dst     = static_cast<int>(dst.shape()[1]);
    const auto z_dst     = static_cast<int>(dst.shape()[2]);
    for(int b = 0; b < b_indices; ++b)
    {
        for(int r = 0; r < z_indices; ++r)
        {
            for(int h = 0; h < h_indices; ++h)
            {
                for(int w = 0; w < w_indices; ++w)
                {
                    const uint32_t index_into_dst = indices[b * z_indices * h_indices * w_indices + r * h_indices * w_indices + h * w_indices + w];
                    const auto     input_val      = src[b * z_indices * h_indices * w_indices + r * h_indices * w_indices + h * w_indices + w];
                    auto          *ptr            = &dst[b * z_dst * h_dst * w_dst];
                    ptr[index_into_dst]           = input_val;
                }
            }
        }
    }
    return dst;
}

References ARM_COMPUTE_ERROR_ON, ARM_COMPUTE_UNUSED, arm_compute::test::validation::b, arm_compute::test::validation::data_layout, arm_compute::test::validation::dst, arm_compute::test::validation::info, arm_compute::test::validation::output_shape, SimpleTensor< T >::shape(), arm_compute::test::validation::src, and arm_compute::test::validation::w.

mean_and_standard_deviation() [1/4]

template std::pair<float, float> arm_compute::test::validation::reference::mean_and_standard_deviation

(

const SimpleTensor< float > &

in

)

mean_and_standard_deviation() [2/4]

template std::pair<float, float> arm_compute::test::validation::reference::mean_and_standard_deviation

(

const SimpleTensor< half > &

in

)

mean_and_standard_deviation() [3/4]

std::pair< float, float > mean_and_standard_deviation

(

const SimpleTensor< T > &

in

)

Definition at line 35 of file MeanStdDev.cpp.

{
    const int num_elements = in.num_elements();
 
    // Calculate mean
    float mean = std::accumulate(in.data(), in.data() + num_elements, 0.f) / num_elements;
 
    // Calculate standard deviation
    float std_dev = std::accumulate(in.data(), in.data() + num_elements, 0.f, [&mean](float a, float b)
    {
        return a + (mean - b) * (mean - b);
    });
 
    std_dev = std::sqrt(std_dev / num_elements);
 
    return std::make_pair(mean, std_dev);
}

References accumulate(), arm_compute::test::validation::b, SimpleTensor< T >::data(), and SimpleTensor< T >::num_elements().

mean_and_standard_deviation() [4/4]

template std::pair<float, float> arm_compute::test::validation::reference::mean_and_standard_deviation

(

const SimpleTensor< uint8_t > &

in

)

mean_std_normalization_layer() [1/4]

template SimpleTensor<float> arm_compute::test::validation::reference::mean_std_normalization_layer	(	const SimpleTensor< float > &	src,
		float	epsilon
	)

mean_std_normalization_layer() [2/4]

template SimpleTensor<half> arm_compute::test::validation::reference::mean_std_normalization_layer	(	const SimpleTensor< half > &	src,
		float	epsilon
	)

mean_std_normalization_layer() [3/4]

SimpleTensor< T > mean_std_normalization_layer	(	const SimpleTensor< T > &	src,
		float	epsilon
	)

Definition at line 37 of file MeanStdDevNormalizationLayer.cpp.

{
   SimpleTensor<T> dst{ src.shape(), src.data_type(), 1 };
   const int cols       = src.shape()[0];
   const int batch_size = src.shape()[1];
   for(int i = 0; i < batch_size; ++i)
   {
         float sum    = static_cast<T>(0.f);
         float  sum_sq = static_cast<T>(0.f);
         for(int j = 0; j < cols; ++j)
         {
             const T value = src[j + i * cols];
             sum += value;
             sum_sq += value * value;
         }
         const float  mean       = sum / cols;
         const float var        =  (((sum_sq / cols) - (mean * mean)) + epsilon);
         const float stddev_inv =     1.f / std::sqrt(var);
         for(int j = 0; j < cols; ++j)
         {
             const float res = (src[j + i * cols] - mean) * stddev_inv;
             dst[j + i * cols] = static_cast<T>(res);
         }
    }
    return dst;
}

References caffe_mnist_image_extractor::cols, arm_compute::test::validation::dst, arm_compute::quantization::epsilon, and arm_compute::test::validation::src.

mean_std_normalization_layer() [4/4]

SimpleTensor<uint8_t> arm_compute::test::validation::reference::mean_std_normalization_layer	(	const SimpleTensor< uint8_t > &	src,
		float	epsilon
	)

Definition at line 65 of file MeanStdDevNormalizationLayer.cpp.

{
    SimpleTensor<float>   src_tmp = convert_from_asymmetric(src);
    SimpleTensor<float>   dst_tmp = mean_std_normalization_layer<float>(src_tmp, epsilon);
    SimpleTensor<uint8_t> dst     = convert_to_asymmetric<uint8_t>(dst_tmp, src.quantization_info());
    return dst;
}

References arm_compute::test::validation::convert_from_asymmetric(), arm_compute::test::validation::dst, arm_compute::quantization::epsilon, and arm_compute::test::validation::src.

min_max_location() [1/4]

template MinMaxLocationValues<float> arm_compute::test::validation::reference::min_max_location

(

const SimpleTensor< float > &

src

)

min_max_location() [2/4]

template MinMaxLocationValues<int16_t> arm_compute::test::validation::reference::min_max_location

(

const SimpleTensor< int16_t > &

src

)

min_max_location() [3/4]

MinMaxLocationValues< T > min_max_location

(

const SimpleTensor< T > &

src

)

Definition at line 58 of file MinMaxLocation.cpp.

{
    MinMaxLocationValues<T> dst;
 
    const size_t width = src.shape().x();
 
    compute_min_max<T>(src, dst.min, dst.max);
 
    Coordinates2D coord{ 0, 0 };
 
    for(int i = 0; i < src.num_elements(); ++i)
    {
        coord.x = static_cast<int32_t>(i % width);
        coord.y = static_cast<int32_t>(i / width);
 
        if(src[i] == dst.min)
        {
            dst.min_loc.push_back(coord);
        }
        if(src[i] == dst.max)
        {
            dst.max_loc.push_back(coord);
        }
    }
 
    return dst;
}

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

min_max_location() [4/4]

template MinMaxLocationValues<uint8_t> arm_compute::test::validation::reference::min_max_location

(

const SimpleTensor< uint8_t > &

src

)

non_max_suppression()

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
	)

Definition at line 139 of file NonMaxSuppression.cpp.

{
    const size_t                    num_boxes         = bboxes.shape().y();
    const size_t                    output_size       = std::min(static_cast<size_t>(max_output_size), num_boxes);
    const std::vector<CandidateBox> candidates_vector = get_candidates(scores, score_threshold);
    std::vector<int>                selected;
    for(const auto &c : candidates_vector)
    {
        if(selected.size() == output_size)
        {
            break;
        }
        if(is_box_selected(c, bboxes, selected, nms_threshold))
        {
            selected.push_back(c.first);
        }
    }
    std::copy_n(selected.begin(), selected.size(), indices.data());
 
    for(unsigned int i = selected.size(); i < max_output_size; ++i)
    {
        indices[i] = -1;
    }
 
    return indices;
}

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

non_maxima_suppression() [1/3]

template SimpleTensor<float> arm_compute::test::validation::reference::non_maxima_suppression	(	const SimpleTensor< float > &	src,
		BorderMode	border_mode,
		float	constant_border_value
	)

non_maxima_suppression() [2/3]

SimpleTensor< T > non_maxima_suppression	(	const SimpleTensor< T > &	src,
		BorderMode	border_mode,
		T	constant_border_value
	)

Definition at line 38 of file NonMaximaSuppression.cpp.

{
    constexpr int   block_size = 3;
    SimpleTensor<T> dst(src.shape(), src.data_type(), src.num_channels());
    ValidRegion     valid_region = shape_to_valid_region(src.shape(), border_mode == BorderMode::UNDEFINED, BorderSize(block_size / 2));
 
    const uint32_t num_elements = src.num_elements();
    for(uint32_t i = 0; i < num_elements; ++i)
    {
        Coordinates coord = index2coord(src.shape(), i);
        int         x     = coord.x();
        int         y     = coord.y();
 
        if(!is_in_valid_region(valid_region, coord))
        {
            continue;
        }
 
        if(src[i] >= tensor_elem_at(src, Coordinates(x - 1, y - 1), border_mode, constant_border_value) && src[i] >= tensor_elem_at(src, Coordinates(x, y - 1), border_mode, constant_border_value)
           && src[i] >= tensor_elem_at(src, Coordinates(x + 1, y - 1), border_mode, constant_border_value) && src[i] >= tensor_elem_at(src, Coordinates(x - 1, y), border_mode, constant_border_value)
           && src[i] > tensor_elem_at(src, Coordinates(x + 1, y), border_mode, constant_border_value) && src[i] > tensor_elem_at(src, Coordinates(x - 1, y + 1), border_mode, constant_border_value)
           && src[i] > tensor_elem_at(src, Coordinates(x, y + 1), border_mode, constant_border_value) && src[i] > tensor_elem_at(src, Coordinates(x + 1, y + 1), border_mode, constant_border_value))
        {
            dst[i] = src[i];
        }
        else
        {
            dst[i] = T(0);
        }
    }
 
    return dst;
}

References arm_compute::test::validation::dst, arm_compute::test::index2coord(), arm_compute::test::is_in_valid_region(), arm_compute::test::shape_to_valid_region(), arm_compute::test::validation::src, arm_compute::test::validation::tensor_elem_at(), arm_compute::UNDEFINED, arm_compute::test::validation::valid_region, Dimensions< T >::x(), and Dimensions< T >::y().

non_maxima_suppression() [3/3]

template SimpleTensor<uint8_t> arm_compute::test::validation::reference::non_maxima_suppression	(	const SimpleTensor< uint8_t > &	src,
		BorderMode	border_mode,
		uint8_t	constant_border_value
	)

normalization_layer() [1/3]

template SimpleTensor<float> arm_compute::test::validation::reference::normalization_layer	(	const SimpleTensor< float > &	src,
		NormalizationLayerInfo	info
	)

normalization_layer() [2/3]

template SimpleTensor<half> arm_compute::test::validation::reference::normalization_layer	(	const SimpleTensor< half > &	src,
		NormalizationLayerInfo	info
	)

normalization_layer() [3/3]

SimpleTensor< T > normalization_layer	(	const SimpleTensor< T > &	src,
		NormalizationLayerInfo	info
	)

Definition at line 37 of file NormalizationLayer.cpp.

{
    // Create reference
    SimpleTensor<T> dst{ src.shape(), src.data_type(), 1 };
 
    // Compute reference
    const uint32_t norm_size = info.norm_size();
    NormType       type      = info.type();
    float          beta      = info.beta();
    uint32_t       kappa     = info.kappa();
 
    const int cols       = src.shape()[0];
    const int rows       = src.shape()[1];
    const int depth      = src.shape()[2];
    int       upper_dims = src.shape().total_size() / (cols * rows);
 
    float coeff       = info.scale_coeff();
    int   radius_cols = norm_size / 2;
 
    // IN_MAP_1D and CROSS_MAP normalize over a single axis only
    int radius_rows = (NormType::IN_MAP_2D == type) ? norm_size / 2 : 0;
 
    if(info.is_cross_map())
    {
        // Remove also depth from upper dimensions since it is the dimension we
        // want to use for normalization
        upper_dims /= depth;
 
        for(int r = 0; r < upper_dims; ++r)
        {
            for(int i = 0; i < rows; ++i)
            {
                for(int k = 0; k < cols; ++k)
                {
                    for(int l = 0; l < depth; ++l)
                    {
                        float accumulated_scale = 0.f;
 
                        for(int j = -radius_cols; j <= radius_cols; ++j)
                        {
                            const int z = l + j;
 
                            if(z >= 0 && z < depth)
                            {
                                const T value = src[k + i * cols + z * rows * cols + r * cols * rows * depth];
                                accumulated_scale += value * value;
                            }
                        }
 
                        dst[k + i * cols + l * rows * cols + r * cols * rows * depth] = kappa + accumulated_scale * coeff;
                    }
                }
            }
        }
    }
    else
    {
        for(int r = 0; r < upper_dims; ++r)
        {
            for(int i = 0; i < rows; ++i)
            {
                for(int k = 0; k < cols; ++k)
                {
                    float accumulated_scale = 0.f;
 
                    for(int j = -radius_rows; j <= radius_rows; ++j)
                    {
                        const int y = i + j;
                        for(int l = -radius_cols; l <= radius_cols; ++l)
                        {
                            const int x = k + l;
 
                            if((x >= 0 && y >= 0) && (x < cols && y < rows))
                            {
                                const T value = src[x + y * cols + r * cols * rows];
                                accumulated_scale += value * value;
                            }
                        }
                    }
 
                    dst[k + i * cols + r * cols * rows] = kappa + accumulated_scale * coeff;
                }
            }
        }
    }
 
    if(beta == 1.f)
    {
        for(int i = 0; i < dst.num_elements(); ++i)
        {
            dst[i] = src[i] / dst[i];
        }
    }
    else if(beta == 0.5f)
    {
        for(int i = 0; i < dst.num_elements(); ++i)
        {
            dst[i] = src[i] / std::sqrt(dst[i]);
        }
    }
    else
    {
        for(int i = 0; i < dst.num_elements(); ++i)
        {
            dst[i] = src[i] * std::exp(std::log(dst[i]) * -beta);
        }
    }
 
    return dst;
}

References caffe_mnist_image_extractor::cols, arm_compute::test::validation::dst, arm_compute::IN_MAP_2D, arm_compute::test::validation::info, caffe_mnist_image_extractor::rows, arm_compute::test::validation::src, and type.

normalize_planar_yuv_layer() [1/3]

template SimpleTensor<float> arm_compute::test::validation::reference::normalize_planar_yuv_layer	(	const SimpleTensor< float > &	src,
		const SimpleTensor< float > &	mean,
		const SimpleTensor< float > &	std
	)

normalize_planar_yuv_layer() [2/3]

template SimpleTensor<half> arm_compute::test::validation::reference::normalize_planar_yuv_layer	(	const SimpleTensor< half > &	src,
		const SimpleTensor< half > &	mean,
		const SimpleTensor< half > &	std
	)

normalize_planar_yuv_layer() [3/3]

SimpleTensor< T > normalize_planar_yuv_layer	(	const SimpleTensor< T > &	src,
		const SimpleTensor< T > &	mean,
		const SimpleTensor< T > &	std
	)

Definition at line 38 of file NormalizePlanarYUVLayer.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);
 
    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;
                    result[pos]   = (src[pos] - mean[i]) / std[i];
                }
            }
        }
    }
    return result;
}

References caffe_mnist_image_extractor::cols, caffe_mnist_image_extractor::rows, and arm_compute::test::validation::src.

normalize_planar_yuv_layer< int8_t >()

SimpleTensor<int8_t> arm_compute::test::validation::reference::normalize_planar_yuv_layer< int8_t >	(	const SimpleTensor< int8_t > &	src,
		const SimpleTensor< int8_t > &	mean,
		const SimpleTensor< int8_t > &	std
	)

Definition at line 76 of file NormalizePlanarYUVLayer.cpp.

{
    SimpleTensor<float>  src_tmp  = convert_from_asymmetric(src);
    SimpleTensor<float>  mean_tmp = convert_from_asymmetric(mean);
    SimpleTensor<float>  std_tmp  = convert_from_asymmetric(std);
    SimpleTensor<float>  dst_tmp  = normalize_planar_yuv_layer<float>(src_tmp, mean_tmp, std_tmp);
    SimpleTensor<int8_t> dst      = convert_to_asymmetric<int8_t>(dst_tmp, src.quantization_info());
    return dst;
}

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

normalize_planar_yuv_layer< uint8_t >()

SimpleTensor<uint8_t> arm_compute::test::validation::reference::normalize_planar_yuv_layer< uint8_t >	(	const SimpleTensor< uint8_t > &	src,
		const SimpleTensor< uint8_t > &	mean,
		const SimpleTensor< uint8_t > &	std
	)

Definition at line 65 of file NormalizePlanarYUVLayer.cpp.

{
    SimpleTensor<float>   src_tmp  = convert_from_asymmetric(src);
    SimpleTensor<float>   mean_tmp = convert_from_asymmetric(mean);
    SimpleTensor<float>   std_tmp  = convert_from_asymmetric(std);
    SimpleTensor<float>   dst_tmp  = normalize_planar_yuv_layer<float>(src_tmp, mean_tmp, std_tmp);
    SimpleTensor<uint8_t> dst      = convert_to_asymmetric<uint8_t>(dst_tmp, src.quantization_info());
    return dst;
}

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

pad_layer() [1/9]

template SimpleTensor<float> arm_compute::test::validation::reference::pad_layer	(	const SimpleTensor< float > &	src,
		const PaddingList &	paddings,
		const PixelValue	const_value = PixelValue(),
		const PaddingMode	mode
	)

pad_layer() [2/9]

template SimpleTensor<half> arm_compute::test::validation::reference::pad_layer	(	const SimpleTensor< half > &	src,
		const PaddingList &	paddings,
		const PixelValue	const_value = PixelValue(),
		const PaddingMode	mode
	)

pad_layer() [3/9]

template SimpleTensor<int16_t> arm_compute::test::validation::reference::pad_layer	(	const SimpleTensor< int16_t > &	src,
		const PaddingList &	paddings,
		const PixelValue	const_value = PixelValue(),
		const PaddingMode	mode
	)

pad_layer() [4/9]

template SimpleTensor<int32_t> arm_compute::test::validation::reference::pad_layer	(	const SimpleTensor< int32_t > &	src,
		const PaddingList &	paddings,
		const PixelValue	const_value = PixelValue(),
		const PaddingMode	mode
	)

pad_layer() [5/9]

template SimpleTensor<int8_t> arm_compute::test::validation::reference::pad_layer	(	const SimpleTensor< int8_t > &	src,
		const PaddingList &	paddings,
		const PixelValue	const_value = PixelValue(),
		const PaddingMode	mode
	)

pad_layer() [6/9]

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.

This function is not supposed to be optimized, but to clearly and naively execute the padding of a tensor

Parameters

[in]	src	Tensor to pad
[in]	paddings	Padding size in each dimension
[in]	const_value	Constant value to fill padding with
[in]	mode	[optional] Padding mode to use

Returns

The padded Tensor

Definition at line 39 of file PadLayer.cpp.

{
    const DataType dst_data_type = src.data_type();
 
    const TensorShape orig_shape = src.shape();
 
    std::vector<PaddingInfo> paddings_extended = paddings;
 
    for(size_t i = paddings.size(); i < TensorShape::num_max_dimensions; ++i)
    {
        paddings_extended.emplace_back(PaddingInfo{ 0, 0 });
    }
 
    const TensorShape padded_shape = misc::shape_calculator::compute_padded_shape(orig_shape, paddings);
 
    SimpleTensor<T> dst(padded_shape, dst_data_type);
 
    // Reference algorithm: loop over the different dimension of the input.
    const uint32_t num_elements = dst.num_elements();
    for(uint32_t idx = 0; idx < num_elements; ++idx)
    {
        const Coordinates coord = index2coord(padded_shape, idx);
 
        const size_t i = coord.x();
        const size_t j = coord.y();
        const size_t k = coord.z();
        const size_t l = coord[3];
        const size_t m = coord[4];
        const size_t n = coord[5];
 
        const std::array<size_t, TensorShape::num_max_dimensions> dims   = { { 0, 1, 2, 3, 4, 5 } };
        const std::array<size_t, TensorShape::num_max_dimensions> coords = { { i, j, k, l, m, n } };
        auto is_padding_area = [&](size_t i)
        {
            return (coords[i] < paddings_extended[i].first || coords[i] > orig_shape[i] + paddings_extended[i].first - 1);
        };
 
        auto orig_coord_reflect = [&](size_t i)
        {
            if(is_padding_area(i))
            {
                if(coords[i] < paddings_extended[i].first)
                {
                    return paddings_extended[i].first - coords[i];
                }
                else
                {
                    return 2 * orig_shape[i] + paddings_extended[i].first - 2 - coords[i];
                }
            }
            return coords[i] - paddings_extended[i].first;
        };
 
        auto orig_coord_symm = [&](size_t i)
        {
            if(is_padding_area(i))
            {
                if(coords[i] < paddings_extended[i].first)
                {
                    return paddings_extended[i].first - coords[i] - 1;
                }
                else
                {
                    return 2 * orig_shape[i] + paddings_extended[i].first - 1 - coords[i];
                }
            }
            return coords[i] - paddings_extended[i].first;
        };
 
        // If the tuple [i,j,k,l,m] is in the padding area, then simply set the value
        if(std::any_of(dims.begin(), dims.end(), is_padding_area))
        {
            switch(mode)
            {
                case PaddingMode::CONSTANT:
                    const_value.get(dst[idx]);
                    break;
                case PaddingMode::REFLECT:
                {
                    const Coordinates orig_coords{ orig_coord_reflect(0),
                              orig_coord_reflect(1),
                              orig_coord_reflect(2),
                              orig_coord_reflect(3),
                              orig_coord_reflect(4),
                              orig_coord_reflect(5) };
 
                    const size_t idx_src = coord2index(orig_shape, orig_coords);
                    dst[idx]             = src[idx_src];
                    break;
                }
                case PaddingMode::SYMMETRIC:
                {
                    const Coordinates orig_coords{ orig_coord_symm(0),
                              orig_coord_symm(1),
                              orig_coord_symm(2),
                              orig_coord_symm(3),
                              orig_coord_symm(4),
                              orig_coord_symm(5) };
 
                    const size_t idx_src = coord2index(orig_shape, orig_coords);
                    dst[idx]             = src[idx_src];
                    break;
                }
                default:
                    ARM_COMPUTE_ERROR("Padding mode not supported.");
                    break;
            }
        }
        else
        {
            // If the tuple[i,j,k,l,m] is not in the padding area, then copy the input into the output
 
            const Coordinates orig_coords
            {
                i - paddings_extended[0].first,
                j - paddings_extended[1].first,
                k - paddings_extended[2].first,
                l - paddings_extended[3].first,
                m - paddings_extended[4].first,
                n - paddings_extended[5].first
            };
 
            const size_t idx_src = coord2index(orig_shape, orig_coords);
            dst[idx]             = src[idx_src];
        }
    }
 
    return dst;
}

References ARM_COMPUTE_ERROR, arm_compute::misc::shape_calculator::compute_padded_shape(), arm_compute::CONSTANT, arm_compute::test::coord2index(), arm_compute::test::validation::dst, PixelValue::get(), arm_compute::test::index2coord(), clang_tidy_rules::mode, Dimensions< size_t >::num_max_dimensions, arm_compute::REFLECT, arm_compute::test::validation::src, arm_compute::SYMMETRIC, Dimensions< T >::x(), Dimensions< T >::y(), and Dimensions< T >::z().

Referenced by conv2d_dft().

pad_layer() [7/9]

template SimpleTensor<uint16_t> arm_compute::test::validation::reference::pad_layer	(	const SimpleTensor< uint16_t > &	src,
		const PaddingList &	paddings,
		const PixelValue	const_value = PixelValue(),
		const PaddingMode	mode
	)

pad_layer() [8/9]

template SimpleTensor<uint32_t> arm_compute::test::validation::reference::pad_layer	(	const SimpleTensor< uint32_t > &	src,
		const PaddingList &	paddings,
		const PixelValue	const_value = PixelValue(),
		const PaddingMode	mode
	)

pad_layer() [9/9]

template SimpleTensor<uint8_t> arm_compute::test::validation::reference::pad_layer	(	const SimpleTensor< uint8_t > &	src,
		const PaddingList &	paddings,
		const PixelValue	const_value = PixelValue(),
		const PaddingMode	mode
	)

permute() [1/9]

template SimpleTensor<bfloat16> arm_compute::test::validation::reference::permute	(	const SimpleTensor< bfloat16 > &	src,
		PermutationVector	perm
	)

permute() [2/9]

template SimpleTensor<float> arm_compute::test::validation::reference::permute	(	const SimpleTensor< float > &	src,
		PermutationVector	perm
	)

permute() [3/9]

template SimpleTensor<half> arm_compute::test::validation::reference::permute	(	const SimpleTensor< half > &	src,
		PermutationVector	perm
	)

permute() [4/9]

template SimpleTensor<int16_t> arm_compute::test::validation::reference::permute	(	const SimpleTensor< int16_t > &	src,
		PermutationVector	perm
	)

permute() [5/9]

template SimpleTensor<int8_t> arm_compute::test::validation::reference::permute	(	const SimpleTensor< int8_t > &	src,
		PermutationVector	perm
	)

permute() [6/9]

SimpleTensor< T > permute	(	const SimpleTensor< T > &	src,
		PermutationVector	perm
	)

Definition at line 39 of file Permute.cpp.

{
    // Permute shapes
    TensorShape dst_shape = src.shape();
    permute(dst_shape, perm);
 
    // Create reference
    SimpleTensor<T> dst{dst_shape, src.data_type(), src.num_channels(), src.quantization_info()};
 
    // Compute reference
    const uint32_t num_elements = src.num_elements();
    for (uint32_t i = 0; i < num_elements; ++i)
    {
        const Coordinates src_coords = index2coord(src.shape(), i);
        Coordinates       dst_coords = src_coords;
        permute(dst_coords, perm);
 
        std::copy_n(static_cast<const T *>(src(src_coords)), src.num_channels(), static_cast<T *>(dst(dst_coords)));
    }
 
    return dst;
}

References arm_compute::test::validation::dst, arm_compute::test::validation::dst_shape, arm_compute::test::index2coord(), and arm_compute::test::validation::src.

Referenced by dft_2d(), pooling_layer_internal(), rdft_2d(), and ridft_2d().

permute() [7/9]

template SimpleTensor<uint16_t> arm_compute::test::validation::reference::permute	(	const SimpleTensor< uint16_t > &	src,
		PermutationVector	perm
	)

permute() [8/9]

template SimpleTensor<uint32_t> arm_compute::test::validation::reference::permute	(	const SimpleTensor< uint32_t > &	src,
		PermutationVector	perm
	)

permute() [9/9]

template SimpleTensor<uint8_t> arm_compute::test::validation::reference::permute	(	const SimpleTensor< uint8_t > &	src,
		PermutationVector	perm
	)

pixel_wise_multiplication() [1/8]

template SimpleTensor<float> arm_compute::test::validation::reference::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
	)

pixel_wise_multiplication() [2/8]

template SimpleTensor<half_float::half> arm_compute::test::validation::reference::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
	)

pixel_wise_multiplication() [3/8]

template SimpleTensor< int32_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
	)

Definition at line 323 of file PixelWiseMultiplication.cpp.

{
    SimpleTensor<int16_t> dst(TensorShape::broadcast_shape(src1.shape(), src2.shape()), dt_out, 1, qout);
 
    if(src1.data_type() == DataType::QSYMM16 && src2.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  = pixel_wise_multiplication<float, float, float>(src1_tmp, src2_tmp, scale, convert_policy, rounding_policy, DataType::F32, qout);
        dst                          = convert_to_symmetric<int16_t>(dst_tmp, qout);
    }
    else
    {
        if(scale < 0)
        {
            ARM_COMPUTE_ERROR("Scale of pixel-wise multiplication must be non-negative");
        }
 
        Coordinates id_src1{};
        Coordinates id_src2{};
        Coordinates id_dst{};
        BroadcastUnroll<Coordinates::num_max_dimensions>::unroll(src1, src2, dst, scale, convert_policy, rounding_policy, id_src1, id_src2, id_dst);
    }
    return dst;
}

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

pixel_wise_multiplication() [4/8]

template SimpleTensor<int32_t> arm_compute::test::validation::reference::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
	)

pixel_wise_multiplication() [5/8]

SimpleTensor<int8_t> arm_compute::test::validation::reference::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
	)

Definition at line 295 of file PixelWiseMultiplication.cpp.

{
    SimpleTensor<int8_t> dst(TensorShape::broadcast_shape(src1.shape(), src2.shape()), dt_out, 1, qout);
 
    if(src1.data_type() == DataType::QASYMM8_SIGNED && src2.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  = pixel_wise_multiplication<float, float, float>(src1_tmp, src2_tmp, scale, convert_policy, rounding_policy, DataType::F32, qout);
        dst                          = convert_to_asymmetric<int8_t>(dst_tmp, qout);
    }
    else
    {
        if(scale < 0)
        {
            ARM_COMPUTE_ERROR("Scale of pixel-wise multiplication must be non-negative");
        }
 
        Coordinates id_src1{};
        Coordinates id_src2{};
        Coordinates id_dst{};
        BroadcastUnroll<Coordinates::num_max_dimensions>::unroll(src1, src2, dst, scale, convert_policy, rounding_policy, id_src1, id_src2, id_dst);
    }
    return dst;
}

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

pixel_wise_multiplication() [6/8]

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
	)

Definition at line 217 of file PixelWiseMultiplication.cpp.

{
    ARM_COMPUTE_UNUSED(qout);
 
    SimpleTensor<T3> dst(TensorShape::broadcast_shape(src1.shape(), src2.shape()), dt_out);
 
    if(scale < 0)
    {
        ARM_COMPUTE_ERROR("Scale of pixel-wise multiplication must be non-negative");
    }
 
    Coordinates id_src1{};
    Coordinates id_src2{};
    Coordinates id_dst{};
 
    BroadcastUnroll<Coordinates::num_max_dimensions>::unroll(src1, src2, dst, scale, convert_policy, rounding_policy, id_src1, id_src2, id_dst);
 
    return dst;
}

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

pixel_wise_multiplication() [7/8]

template SimpleTensor<int16_t> arm_compute::test::validation::reference::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
	)

pixel_wise_multiplication() [8/8]

SimpleTensor< int16_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
	)

Definition at line 239 of file PixelWiseMultiplication.cpp.

{
    SimpleTensor<uint8_t> dst(TensorShape::broadcast_shape(src1.shape(), src2.shape()), dt_out, 1, qout);
 
    if(src1.data_type() == DataType::QASYMM8 && src2.data_type() == DataType::QASYMM8)
    {
        SimpleTensor<float> src1_tmp = convert_from_asymmetric(src1);
        SimpleTensor<float> src2_tmp = convert_from_asymmetric(src2);
        SimpleTensor<float> dst_tmp  = pixel_wise_multiplication<float, float, float>(src1_tmp, src2_tmp, scale, convert_policy, rounding_policy, DataType::F32, qout);
        dst                          = convert_to_asymmetric<uint8_t>(dst_tmp, qout);
    }
    else
    {
        if(scale < 0)
        {
            ARM_COMPUTE_ERROR("Scale of pixel-wise multiplication must be non-negative");
        }
 
        Coordinates id_src1{};
        Coordinates id_src2{};
        Coordinates id_dst{};
        BroadcastUnroll<Coordinates::num_max_dimensions>::unroll(src1, src2, dst, scale, convert_policy, rounding_policy, id_src1, id_src2, id_dst);
    }
    return dst;
}

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

pooling_3d_layer() [1/3]

template SimpleTensor<float> arm_compute::test::validation::reference::pooling_3d_layer	(	const SimpleTensor< float > &	src,
		const Pooling3dLayerInfo &	pool3d_info,
		const QuantizationInfo &	output_qinfo,
		SimpleTensor< uint32_t > *	indices
	)

pooling_3d_layer() [2/3]

template SimpleTensor<half> arm_compute::test::validation::reference::pooling_3d_layer	(	const SimpleTensor< half > &	src,
		const Pooling3dLayerInfo &	pool3d_info,
		const QuantizationInfo &	output_qinfo,
		SimpleTensor< uint32_t > *	indices
	)

pooling_3d_layer() [3/3]

SimpleTensor< T > pooling_3d_layer	(	const SimpleTensor< T > &	src,
		const Pooling3dLayerInfo &	pool3d_info,
		const QuantizationInfo &	output_qinfo,
		SimpleTensor< uint32_t > *	indices
	)

Definition at line 195 of file Pooling3dLayer.cpp.

{
    ARM_COMPUTE_UNUSED(output_qinfo);
    return pooling_3d_layer_internal<T>(src, pool3d_info, indices);
}

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

pooling_3d_layer< int8_t >()

SimpleTensor<int8_t> arm_compute::test::validation::reference::pooling_3d_layer< int8_t >	(	const SimpleTensor< int8_t > &	src,
		const Pooling3dLayerInfo &	pool3d_info,
		const QuantizationInfo &	output_qinfo,
		SimpleTensor< uint32_t > *	indices
	)

Definition at line 202 of file Pooling3dLayer.cpp.

{
    SimpleTensor<float> src_tmp = convert_from_asymmetric(src);
    SimpleTensor<float> dst_tmp = pooling_3d_layer_internal<float>(src_tmp, pool3d_info, indices);
    return convert_to_asymmetric<int8_t>(dst_tmp, output_qinfo);
}

References arm_compute::test::validation::convert_from_asymmetric(), and arm_compute::test::validation::src.

pooling_3d_layer< uint8_t >()

SimpleTensor<uint8_t> arm_compute::test::validation::reference::pooling_3d_layer< uint8_t >	(	const SimpleTensor< uint8_t > &	src,
		const Pooling3dLayerInfo &	pool3d_info,
		const QuantizationInfo &	output_qinfo,
		SimpleTensor< uint32_t > *	indices
	)

Definition at line 210 of file Pooling3dLayer.cpp.

{
    SimpleTensor<float> src_tmp = convert_from_asymmetric(src);
    SimpleTensor<float> dst_tmp = pooling_3d_layer_internal<float>(src_tmp, pool3d_info, indices);
    return convert_to_asymmetric<uint8_t>(dst_tmp, output_qinfo);
}

References arm_compute::test::validation::convert_from_asymmetric(), and arm_compute::test::validation::src.

pooling_3d_layer_internal()

SimpleTensor< T > pooling_3d_layer_internal	(	const SimpleTensor< T > &	src,
		const Pooling3dLayerInfo &	pool3d_info,
		SimpleTensor< uint32_t > *	indices
	)

Definition at line 40 of file Pooling3dLayer.cpp.

{
    TensorShape     pooled_shape = compute_pool3d_shape(src.shape(), pool3d_info);
    SimpleTensor<T> dst{ pooled_shape, src.data_type(), 1 };
 
    if(indices != nullptr)
    {
        *indices = SimpleTensor<uint32_t> { pooled_shape, DataType::U32, 1 };
    }
 
    const int idx_channel = 0;
    const int idx_width   = 1;
    const int idx_height  = 2;
    const int idx_depth   = 3;
    const int idx_batch   = 4;
 
    const int pool_size_width  = pool3d_info.is_global_pooling ? src.shape()[idx_width] : pool3d_info.pool_size.width;
    const int pool_size_height = pool3d_info.is_global_pooling ? src.shape()[idx_height] : pool3d_info.pool_size.height;
    const int pool_size_depth  = pool3d_info.is_global_pooling ? src.shape()[idx_depth] : pool3d_info.pool_size.depth;
 
    const int pool_stride_width  = static_cast<int>(pool3d_info.stride.width);
    const int pool_stride_height = static_cast<int>(pool3d_info.stride.height);
    const int pool_stride_depth  = static_cast<int>(pool3d_info.stride.depth);
 
    const int pad_left  = static_cast<int>(pool3d_info.padding.left);
    const int pad_top   = static_cast<int>(pool3d_info.padding.top);
    const int pad_front = static_cast<int>(pool3d_info.padding.front);
 
    const int pad_right  = static_cast<int>(pool3d_info.padding.right);
    const int pad_bottom = static_cast<int>(pool3d_info.padding.bottom);
    const int pad_back   = static_cast<int>(pool3d_info.padding.back);
 
    const int num_channels = static_cast<int>(src.shape()[idx_channel]);
    const int num_batches  = static_cast<int>(src.shape()[idx_batch]);
 
    ARM_COMPUTE_ERROR_ON(num_channels != static_cast<int>(dst.shape()[idx_channel]));
    ARM_COMPUTE_ERROR_ON(num_batches != static_cast<int>(dst.shape()[idx_batch]));
 
    const int w_src = static_cast<int>(src.shape()[idx_width]);
    const int h_src = static_cast<int>(src.shape()[idx_height]);
    const int d_src = static_cast<int>(src.shape()[idx_depth]);
    const int w_dst = static_cast<int>(dst.shape()[idx_width]);
    const int h_dst = static_cast<int>(dst.shape()[idx_height]);
    const int d_dst = static_cast<int>(dst.shape()[idx_depth]);
 
    const bool exclude_padding = pool3d_info.exclude_padding;
 
    const int height_stride_src = num_channels * w_src;
    const int depth_stride_src  = height_stride_src * h_src;
    const int batch_stride_src  = depth_stride_src * d_src;
    const int height_stride_dst = num_channels * w_dst;
    const int depth_stride_dst  = height_stride_dst * h_dst;
    const int batch_stride_dst  = depth_stride_dst * d_dst;
 
    for(int b = 0; b < num_batches; ++b)
    {
        const int batch_offset_dst = b * batch_stride_dst;
        const int batch_offset_src = b * batch_stride_src;
        for(int c = 0; c < num_channels; ++c)
        {
            for(int d = 0; d < d_dst; ++d)
            {
                const int depth_offset_dst = d * depth_stride_dst;
                for(int h = 0; h < h_dst; ++h)
                {
                    const int height_offset_dst = h * height_stride_dst;
                    for(int w = 0; w < w_dst; ++w)
                    {
                        int wstart = w * pool_stride_width - pad_left;
                        int hstart = h * pool_stride_height - pad_top;
                        int dstart = d * pool_stride_depth - pad_front;
                        int wend   = std::min(wstart + pool_size_width, w_src + pad_right);
                        int hend   = std::min(hstart + pool_size_height, h_src + pad_bottom);
                        int dend   = std::min(dstart + pool_size_depth, d_src + pad_back);
 
                        // this may not be equal to pool_w * pool_h * pool_d because of
                        // DimensionRoundingType choice (CEIL)
                        int pool_size = (dend - dstart) * (hend - hstart) * (wend - wstart);
 
                        // limit [start, end) to [0, w_src)
                        wstart = std::max(wstart, 0);
                        hstart = std::max(hstart, 0);
                        dstart = std::max(dstart, 0);
                        wend   = std::min(wend, w_src);
                        hend   = std::min(hend, h_src);
                        dend   = std::min(dend, d_src);
 
                        auto max_val = -std::numeric_limits<T>::infinity();
                        int  max_index{ 0 };
                        T    avg_val = static_cast<T>(0.f);
                        T    l2_val  = static_cast<T>(0.f);
 
                        if(exclude_padding)
                        {
                            pool_size = (dend - dstart) * (hend - hstart) * (wend - wstart);
                        }
 
                        for(int z = dstart; z < dend; ++z)
                        {
                            const int depth_offset_src = z * depth_stride_src;
                            for(int y = hstart; y < hend; ++y)
                            {
                                const int height_offset_src = y * height_stride_src;
                                for(int x = wstart; x < wend; ++x)
                                {
                                    const auto val = static_cast<T>(
                                                         src[batch_offset_src + depth_offset_src + height_offset_src + x * num_channels + c]);
                                    if(val > max_val)
                                    {
                                        max_val   = val;
                                        max_index = coord2index(src.shape(), Coordinates(c, x, y, z, 0));
                                    }
 
                                    avg_val += val;
                                    l2_val += val * val;
                                }
                            }
                        }
 
                        avg_val /= pool_size;
                        l2_val = static_cast<T>(std::sqrt(l2_val / pool_size));
 
                        int dst_index = batch_offset_dst + depth_offset_dst + height_offset_dst + w * num_channels + c;
                        switch(pool3d_info.pool_type)
                        {
                            case PoolingType::MAX:
                                dst[dst_index] = static_cast<T>(max_val);
                                break;
                            case PoolingType::AVG:
                                dst[dst_index] = static_cast<T>(avg_val);
                                break;
                            case PoolingType::L2:
                                dst[dst_index] = static_cast<T>(l2_val);
                                break;
                            default:
                                ARM_COMPUTE_ERROR("Pooling Type should be either MAX, AVG or L2");
                        }
 
                        if(indices != nullptr)
                        {
                            (*indices)[dst_index] = max_index;
                        }
                    }
                }
            }
        }
    }
 
    return dst;
}

References ARM_COMPUTE_ERROR, ARM_COMPUTE_ERROR_ON, arm_compute::AVG, arm_compute::test::validation::b, Padding3D::back, Padding3D::bottom, arm_compute::misc::shape_calculator::compute_pool3d_shape(), arm_compute::test::coord2index(), Size3D::depth, arm_compute::test::validation::dst, Pooling3dLayerInfo::exclude_padding, Padding3D::front, Size3D::height, arm_compute::test::validation::idx_height, arm_compute::test::validation::idx_width, Pooling3dLayerInfo::is_global_pooling, arm_compute::L2, Padding3D::left, arm_compute::MAX, Pooling3dLayerInfo::padding, Pooling3dLayerInfo::pool_size, Pooling3dLayerInfo::pool_type, Padding3D::right, arm_compute::test::validation::src, Pooling3dLayerInfo::stride, Padding3D::top, arm_compute::U32, arm_compute::test::validation::w, and Size3D::width.

pooling_layer() [1/3]

template SimpleTensor<float> arm_compute::test::validation::reference::pooling_layer	(	const SimpleTensor< float > &	src,
		const PoolingLayerInfo &	info,
		const QuantizationInfo &	output_qinfo,
		SimpleTensor< uint32_t > *	indices,
		DataLayout	data_layout
	)

pooling_layer() [2/3]

SimpleTensor<half> arm_compute::test::validation::reference::pooling_layer	(	const SimpleTensor< half > &	src,
		const PoolingLayerInfo &	info,
		const QuantizationInfo &	output_qinfo,
		SimpleTensor< uint32_t > *	indices,
		DataLayout	data_layout
	)

Definition at line 217 of file PoolingLayer.cpp.

{
    ARM_COMPUTE_UNUSED(output_qinfo);
    if(src.data_type() == DataType::F16 && info.fp_mixed_precision)
    {
        return pooling_layer_internal<half, float>(src, info, indices, data_layout);
    }
 
    return pooling_layer_internal<half>(src, info, indices, data_layout);
}

References ARM_COMPUTE_UNUSED, arm_compute::test::validation::data_layout, arm_compute::F16, arm_compute::test::validation::info, pooling_layer_internal< half >(), pooling_layer_internal< half, float >(), and arm_compute::test::validation::src.

pooling_layer() [3/3]

SimpleTensor< T > pooling_layer	(	const SimpleTensor< T > &	src,
		const PoolingLayerInfo &	info,
		const QuantizationInfo &	output_qinfo,
		SimpleTensor< uint32_t > *	indices,
		DataLayout	data_layout
	)

Definition at line 191 of file PoolingLayer.cpp.

{
    ARM_COMPUTE_UNUSED(output_qinfo);
    return pooling_layer_internal<T, T>(src, info, indices, data_layout);
}

References ARM_COMPUTE_UNUSED, arm_compute::test::validation::data_layout, arm_compute::test::validation::info, and arm_compute::test::validation::src.

pooling_layer< int8_t >()

SimpleTensor<int8_t> arm_compute::test::validation::reference::pooling_layer< int8_t >	(	const SimpleTensor< int8_t > &	src,
		const PoolingLayerInfo &	info,
		const QuantizationInfo &	output_qinfo,
		SimpleTensor< uint32_t > *	indices,
		DataLayout	data_layout
	)

Definition at line 208 of file PoolingLayer.cpp.

{
    SimpleTensor<float>  src_tmp = convert_from_asymmetric(src);
    SimpleTensor<float>  dst_tmp = pooling_layer_internal<float>(src_tmp, info, indices, data_layout);
    SimpleTensor<int8_t> dst     = convert_to_asymmetric<int8_t>(dst_tmp, output_qinfo);
    return dst;
}

References arm_compute::test::validation::convert_from_asymmetric(), arm_compute::test::validation::data_layout, arm_compute::test::validation::dst, arm_compute::test::validation::info, pooling_layer_internal< float >(), and arm_compute::test::validation::src.

pooling_layer< uint8_t >()

SimpleTensor<uint8_t> arm_compute::test::validation::reference::pooling_layer< uint8_t >	(	const SimpleTensor< uint8_t > &	src,
		const PoolingLayerInfo &	info,
		const QuantizationInfo &	output_qinfo,
		SimpleTensor< uint32_t > *	indices,
		DataLayout	data_layout
	)

Definition at line 198 of file PoolingLayer.cpp.

{
    SimpleTensor<float>   src_tmp = convert_from_asymmetric(src);
    SimpleTensor<float>   dst_tmp = pooling_layer_internal<float>(src_tmp, info, indices, data_layout);
    SimpleTensor<uint8_t> dst     = convert_to_asymmetric<uint8_t>(dst_tmp, output_qinfo);
    return dst;
}

References arm_compute::test::validation::convert_from_asymmetric(), arm_compute::test::validation::data_layout, arm_compute::test::validation::dst, arm_compute::test::validation::info, pooling_layer_internal< float >(), and arm_compute::test::validation::src.

pooling_layer_internal()

SimpleTensor< T > pooling_layer_internal	(	const SimpleTensor< T > &	src,
		const PoolingLayerInfo &	info,
		SimpleTensor< uint32_t > *	indices,
		DataLayout	data_layout
	)

Definition at line 41 of file PoolingLayer.cpp.

{
    // Create reference
    SimpleTensor<T> dst{ compute_pool_shape(TensorInfo(src.shape(), 1, src.data_type()), info), src.data_type(), 1 };
    auto            pooled_shape = compute_pool_shape(TensorInfo(src.shape(), 1, src.data_type()), info);
    if(indices)
    {
        *indices = SimpleTensor<uint32_t> { pooled_shape, DataType::U32, 1 };
    }
    const int   pool_size_x     = info.is_global_pooling ? src.shape().x() : info.pool_size.width;
    const int   pool_size_y     = info.is_global_pooling ? src.shape().y() : info.pool_size.height;
    PoolingType type            = info.pool_type;
    int         pool_stride_x   = info.pad_stride_info.stride().first;
    int         pool_stride_y   = info.pad_stride_info.stride().second;
    int         pad_left        = info.pad_stride_info.pad_left();
    int         pad_top         = info.pad_stride_info.pad_top();
    int         pad_right       = info.pad_stride_info.pad_right();
    int         pad_bottom      = info.pad_stride_info.pad_bottom();
    bool        exclude_padding = info.exclude_padding;
 
    const auto w_src = static_cast<int>(src.shape()[0]);
    const auto h_src = static_cast<int>(src.shape()[1]);
    const auto z_src = static_cast<int>(src.shape()[2]);
    const auto b_src = static_cast<int>(src.shape()[3]);
 
    const int upper_dims = src.shape().total_size() / (w_src * h_src);
 
    const auto w_dst = static_cast<int>(dst.shape()[0]);
    const auto h_dst = static_cast<int>(dst.shape()[1]);
    const auto z_dst = static_cast<int>(dst.shape()[2]);
 
    TensorShape shape_nhwc(src.shape());
    permute(shape_nhwc, PermutationVector(2U, 0U, 1U));
    if(type == PoolingType::MAX)
    {
        for(int b = 0; b < b_src; ++b)
        {
            for(int r = 0; r < z_src; ++r)
            {
                for(int h = 0; h < h_dst; ++h)
                {
                    for(int w = 0; w < w_dst; ++w)
                    {
                        int wstart   = w * pool_stride_x - pad_left;
                        int hstart   = h * pool_stride_y - pad_top;
 
                        // Used to calculate kernel indices
                        int  kh_start = std::max(0, -hstart);
                        int  kw_start = std::max(0, -wstart);
                        int  max_ker_index{ 0 };
 
                        int wend     = std::min(wstart + pool_size_x, w_src);
                        int hend     = std::min(hstart + pool_size_y, h_src);
                        wstart       = std::max(wstart, 0);
                        hstart       = std::max(hstart, 0);
                        auto max_val = info.use_inf_as_limit ? -std::numeric_limits<ACC_T>::infinity() : std::numeric_limits<ACC_T>::lowest();
                        int  max_index{ 0 };
 
                        for(int y = hstart, kh = kh_start; y < hend; ++y, ++kh)
                        {
                            for(int x = wstart, kw = kw_start; x < wend; ++x, ++kw)
                            {
                                const auto val = static_cast<ACC_T>(src[b * z_src * h_src * w_src + r * h_src * w_src + y * w_src + x]);
                                if(val > max_val)
                                {
                                    max_val   = val;
                                    max_ker_index = pool_size_x * (kh) + (kw);
                                    if(data_layout == DataLayout::NCHW)
                                    {
                                        max_index = coord2index(src.shape(), Coordinates(x, y, r, 0));
                                    }
                                    else
                                    {
                                        max_index = coord2index(shape_nhwc, Coordinates(r, x, y, 0));
                                    }
                                }
                            }
                        }
 
                        dst[b * z_dst * h_dst * w_dst + r * h_dst * w_dst + h * w_dst + w] = static_cast<T>(max_val);
                        if(indices)
                        {
                            (*indices)[b * z_dst * h_dst * w_dst + r * h_dst * w_dst + h * w_dst + w] = (info.use_kernel_indices) ? max_ker_index : max_index;
                        }
                    }
                }
            }
        }
    }
    else // Average or l2 pooling
    {
        for(int r = 0; r < upper_dims; ++r)
        {
            for(int h = 0; h < h_dst; ++h)
            {
                for(int w = 0; w < w_dst; ++w)
                {
                    ACC_T avg_val(0);
                    int   wstart = w * pool_stride_x - pad_left;
                    int   hstart = h * pool_stride_y - pad_top;
                    int   wend   = std::min(wstart + pool_size_x, w_src + pad_right);
                    int   hend   = std::min(hstart + pool_size_y, h_src + pad_bottom);
                    int   pool   = (hend - hstart) * (wend - wstart);
                    wstart       = std::max(wstart, 0);
                    hstart       = std::max(hstart, 0);
                    wend         = std::min(wend, w_src);
                    hend         = std::min(hend, h_src);
                    // Exclude padding pixels from the average
                    if(exclude_padding)
                    {
                        pool = (hend - hstart) * (wend - wstart);
                    }
 
                    if(type == PoolingType::AVG)
                    {
                        for(int y = hstart; y < hend; ++y)
                        {
                            for(int x = wstart; x < wend; ++x)
                            {
                                avg_val += static_cast<ACC_T>(src[r * h_src * w_src + y * w_src + x]);
                            }
                        }
                        dst[r * h_dst * w_dst + h * w_dst + w] = avg_val / pool;
                    }
                    else
                    {
                        for(int y = hstart; y < hend; ++y)
                        {
                            for(int x = wstart; x < wend; ++x)
                            {
                                const auto val = static_cast<ACC_T>(src[r * h_src * w_src + y * w_src + x]);
                                avg_val += val * val;
                            }
                        }
                        dst[r * h_dst * w_dst + h * w_dst + w] = static_cast<T>(std::sqrt(avg_val / pool));
                    }
                }
            }
        }
    }
    return dst;
}

References arm_compute::AVG, arm_compute::test::validation::b, arm_compute::misc::shape_calculator::compute_pool_shape(), arm_compute::test::coord2index(), arm_compute::test::validation::data_layout, arm_compute::test::validation::dst, arm_compute::test::validation::info, arm_compute::support::cpp11::lowest(), arm_compute::MAX, arm_compute::NCHW, permute(), arm_compute::test::validation::src, type, arm_compute::utils::cast::U, arm_compute::U32, and arm_compute::test::validation::w.

pooling_layer_internal< float >()

template SimpleTensor<float> arm_compute::test::validation::reference::pooling_layer_internal< float >	(	const SimpleTensor< float > &	src,
		const PoolingLayerInfo &	info,
		SimpleTensor< uint32_t > *	indices,
		DataLayout	data_layout
	)

Referenced by pooling_layer< int8_t >(), and pooling_layer< uint8_t >().

pooling_layer_internal< half >()

template SimpleTensor<half> arm_compute::test::validation::reference::pooling_layer_internal< half >	(	const SimpleTensor< half > &	src,
		const PoolingLayerInfo &	info,
		SimpleTensor< uint32_t > *	indices,
		DataLayout	data_layout
	)

Referenced by pooling_layer().

pooling_layer_internal< half, float >()

template SimpleTensor<half> arm_compute::test::validation::reference::pooling_layer_internal< half, float >	(	const SimpleTensor< half > &	src,
		const PoolingLayerInfo &	info,
		SimpleTensor< uint32_t > *	indices,
		DataLayout	data_layout
	)

Referenced by pooling_layer().

prior_box_layer() [1/2]

template SimpleTensor<float> arm_compute::test::validation::reference::prior_box_layer	(	const SimpleTensor< float > &	src1,
		const SimpleTensor< float > &	src2,
		const PriorBoxLayerInfo &	info,
		const TensorShape &	output_shape
	)

prior_box_layer() [2/2]

SimpleTensor< T > prior_box_layer	(	const SimpleTensor< T > &	src1,
		const SimpleTensor< T > &	src2,
		const PriorBoxLayerInfo &	info,
		const TensorShape &	output_shape
	)

Definition at line 39 of file PriorBoxLayer.cpp.

{
    const auto layer_width  = static_cast<int>(src1.shape()[0]);
    const auto layer_height = static_cast<int>(src1.shape()[1]);
 
    int img_width  = info.img_size().x;
    int img_height = info.img_size().y;
    if(img_width == 0 || img_height == 0)
    {
        img_width  = static_cast<int>(src2.shape()[0]);
        img_height = static_cast<int>(src2.shape()[1]);
    }
 
    float step_x = info.steps()[0];
    float step_y = info.steps()[1];
    if(step_x == 0.f || step_y == 0.f)
    {
        step_x = static_cast<float>(img_width) / layer_width;
        step_x = static_cast<float>(img_height) / layer_height;
    }
 
    // Calculate number of aspect ratios
    const int num_priors     = info.aspect_ratios().size() * info.min_sizes().size() + info.max_sizes().size();
    const int total_elements = layer_width * layer_height * num_priors * 4;
 
    SimpleTensor<T> result(output_shape, src1.data_type());
 
    int idx = 0;
    for(int y = 0; y < layer_height; ++y)
    {
        for(int x = 0; x < layer_width; ++x)
        {
            const float center_x = (x + info.offset()) * step_x;
            const float center_y = (y + info.offset()) * step_y;
            float       box_width;
            float       box_height;
            for(unsigned int i = 0; i < info.min_sizes().size(); ++i)
            {
                const float min_size = info.min_sizes().at(i);
                box_width            = min_size;
                box_height           = min_size;
                // (xmin, ymin, xmax, ymax)
                result[idx++] = (center_x - box_width / 2.f) / img_width;
                result[idx++] = (center_y - box_height / 2.f) / img_height;
                result[idx++] = (center_x + box_width / 2.f) / img_width;
                result[idx++] = (center_y + box_height / 2.f) / img_height;
 
                if(!info.max_sizes().empty())
                {
                    const float max_size = info.max_sizes().at(i);
                    box_width            = sqrt(min_size * max_size);
                    box_height           = box_width;
 
                    // (xmin, ymin, xmax, ymax)
                    result[idx++] = (center_x - box_width / 2.f) / img_width;
                    result[idx++] = (center_y - box_height / 2.f) / img_height;
                    result[idx++] = (center_x + box_width / 2.f) / img_width;
                    result[idx++] = (center_y + box_height / 2.f) / img_height;
                }
 
                // rest of priors
                for(auto ar : info.aspect_ratios())
                {
                    if(fabs(ar - 1.) < 1e-6)
                    {
                        continue;
                    }
 
                    box_width  = min_size * sqrt(ar);
                    box_height = min_size / sqrt(ar);
 
                    // (xmin, ymin, xmax, ymax)
                    result[idx++] = (center_x - box_width / 2.f) / img_width;
                    result[idx++] = (center_y - box_height / 2.f) / img_height;
                    result[idx++] = (center_x + box_width / 2.f) / img_width;
                    result[idx++] = (center_y + box_height / 2.f) / img_height;
                }
            }
        }
    }
 
    // clip the coordinates
    if(info.clip())
    {
        for(int i = 0; i < total_elements; ++i)
        {
            result[i] = std::min<T>(std::max<T>(result[i], 0.f), 1.f);
        }
    }
 
    // set the variance.
    if(info.variances().size() == 1)
    {
        std::fill_n(result.data() + idx, total_elements, info.variances().at(0));
    }
    else
    {
        for(int h = 0; h < layer_height; ++h)
        {
            for(int w = 0; w < layer_width; ++w)
            {
                for(int i = 0; i < num_priors; ++i)
                {
                    for(int j = 0; j < 4; ++j)
                    {
                        result[idx++] = info.variances().at(j);
                    }
                }
            }
        }
    }
 
    return result;
}

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

qlstm_layer_normalization()

SimpleTensor< int16_t > qlstm_layer_normalization	(	const SimpleTensor< int16_t > &	src,
		const SimpleTensor< int16_t > &	weight,
		const SimpleTensor< int32_t > &	bias
	)

Definition at line 40 of file QLSTMLayerNormalization.cpp.

{
    ARM_COMPUTE_ERROR_ON(src.shape().num_dimensions() > 2);
    SimpleTensor<int16_t> output{ src.shape(), DataType::QSYMM16 };
 
    const auto wq_info = weight.quantization_info().uniform();
    int        output_multiplier{};
    int        output_shift{};
    const auto s = quantization::calculate_quantized_multiplier(wq_info.scale, &output_multiplier, &output_shift);
    output_shift *= -1;
 
    if(!bool(s))
    {
        output_multiplier = 0;
        output_shift      = 0;
    }
 
    const uint32_t num_batch = src.shape()[1];
    const uint32_t num_input = src.shape()[0];
 
    for(uint32_t batch_idx = 0; batch_idx < num_batch; ++batch_idx)
    {
        int64_t sum{};
        int64_t sum_sq{};
 
        for(uint32_t input_idx = 0; input_idx < num_input; ++input_idx)
        {
            const auto index = batch_idx * num_input + input_idx;
            const auto val   = static_cast<int32_t>(src[index]);
            sum += val;
            sum_sq += val * val;
        }
 
        const auto temp     = static_cast<int64_t>(0x100000) / num_input;
        const auto mean     = sum * 1024 / static_cast<int64_t>(num_input);
        const auto variance = ((sum_sq * temp) - (mean * mean)) / 0x100000;
 
        int32_t stddev_invsqrt_mul{};
        int32_t stddev_invsqrt_shift{};
        quantization::get_invsqrt_quantized_multiplier_exp(variance, -1, stddev_invsqrt_mul, stddev_invsqrt_shift);
 
        for(uint32_t input_idx = 0; input_idx < num_input; ++input_idx)
        {
            const auto    index           = batch_idx * num_input + input_idx;
            const auto    val             = static_cast<int32_t>(src[index]);
            const auto    shifted         = (val << 10) - mean;
            const auto    rescaled        = quantization::multiply_by_quantized_multiplier(shifted, stddev_invsqrt_mul, stddev_invsqrt_shift);
            const int64_t weighted        = rescaled * weight[input_idx] + bias[input_idx];
            const auto    reverse_shifted = static_cast<int32_t>((weighted + 512) >> 10);
            auto          out_val         = quantization::multiply_by_quantized_multiplier(reverse_shifted, output_multiplier, output_shift + 12);
            out_val                       = arm_compute::utility::clamp<decltype(out_val), int16_t>(out_val, std::numeric_limits<int16_t>::min());
            output[index]                 = static_cast<int16_t>(out_val);
        }
    }
    return output;
}

References ARM_COMPUTE_ERROR_ON, bias, arm_compute::quantization::calculate_quantized_multiplier(), arm_compute::quantization::get_invsqrt_quantized_multiplier_exp(), arm_compute::quantization::multiply_by_quantized_multiplier(), arm_compute::QSYMM16, SimpleTensor< T >::quantization_info(), and arm_compute::test::validation::src.

quantization_layer() [1/5]

template SimpleTensor< uint16_t > quantization_layer	(	const SimpleTensor< float > &	src,
		DataType	output_data_type,
		const QuantizationInfo &	quantization_info
	)

quantization_layer() [2/5]

template SimpleTensor< uint16_t > quantization_layer	(	const SimpleTensor< half > &	src,
		DataType	output_data_type,
		const QuantizationInfo &	quantization_info
	)

quantization_layer() [3/5]

SimpleTensor< int8_t > quantization_layer	(	const SimpleTensor< int8_t > &	src,
		DataType	output_data_type,
		const QuantizationInfo &	quantization_info
	)

Definition at line 104 of file QuantizationLayer.cpp.

{
    SimpleTensor<float> src_tmp = convert_from_asymmetric<int8_t>(src);
    return quantization_layer<float, uint8_t>(src_tmp, output_data_type, quantization_info);
}

References arm_compute::test::validation::src.

quantization_layer() [4/5]

SimpleTensor< Tout > quantization_layer	(	const SimpleTensor< Tin > &	src,
		DataType	output_data_type,
		const QuantizationInfo &	quantization_info
	)

Definition at line 37 of file QuantizationLayer.cpp.

{
    // Create reference
    SimpleTensor<Tout> dst{ src.shape(), output_data_type, 1, quantization_info };
 
    const UniformQuantizationInfo qinfo = quantization_info.uniform();
 
#ifdef __aarch64__
    constexpr auto rounding_policy = RoundingPolicy::TO_NEAREST_EVEN;
#else  // __aarch64__
    constexpr auto rounding_policy = RoundingPolicy::TO_ZERO;
#endif // __aarch64__
 
    switch(output_data_type)
    {
        case DataType::QASYMM8:
#if defined(_OPENMP)
            #pragma omp parallel for
#endif /* _OPENMP */
            for(int i = 0; i < src.num_elements(); ++i)
            {
                dst[i] = quantize_qasymm8((src[i]), qinfo, rounding_policy);
            }
            break;
        case DataType::QASYMM8_SIGNED:
#if defined(_OPENMP)
            #pragma omp parallel for
#endif /* _OPENMP */
            for(int i = 0; i < src.num_elements(); ++i)
            {
#ifdef __aarch64__
                dst[i] = quantize_qasymm8_signed((src[i]), qinfo, RoundingPolicy::TO_NEAREST_EVEN);
#else  // __aarch64__
                dst[i] = quantize_qasymm8_signed((src[i]), qinfo, RoundingPolicy::TO_ZERO);
#endif // __aarch64__
            }
            break;
        case DataType::QASYMM16:
#if defined(_OPENMP)
            #pragma omp parallel for
#endif /* _OPENMP */
            for(int i = 0; i < src.num_elements(); ++i)
            {
                dst[i] = quantize_qasymm16((src[i]), qinfo, rounding_policy);
            }
            break;
        default:
            ARM_COMPUTE_ERROR("Unsupported output data type");
    }
    return dst;
}

References ARM_COMPUTE_ERROR, arm_compute::test::validation::dst, arm_compute::QASYMM16, arm_compute::QASYMM8, arm_compute::QASYMM8_SIGNED, arm_compute::test::validation::qinfo, arm_compute::quantize_qasymm16(), arm_compute::quantize_qasymm8(), arm_compute::quantize_qasymm8_signed(), arm_compute::test::validation::src, arm_compute::TO_NEAREST_EVEN, arm_compute::TO_ZERO, and QuantizationInfo::uniform().

quantization_layer() [5/5]

SimpleTensor< uint16_t > quantization_layer	(	const SimpleTensor< uint8_t > &	src,
		DataType	output_data_type,
		const QuantizationInfo &	quantization_info
	)

Definition at line 90 of file QuantizationLayer.cpp.

{
    SimpleTensor<float> src_tmp = convert_from_asymmetric<uint8_t>(src);
    return quantization_layer<float, uint8_t>(src_tmp, output_data_type, quantization_info);
}

References arm_compute::test::validation::src.

range() [1/7]

template SimpleTensor<float> arm_compute::test::validation::reference::range	(	SimpleTensor< float > &	dst,
		float	start,
		const size_t	num_of_elements,
		float	step
	)

range() [2/7]

template SimpleTensor<half> arm_compute::test::validation::reference::range	(	SimpleTensor< half > &	dst,
		float	start,
		const size_t	num_of_elements,
		float	step
	)

range() [3/7]

template SimpleTensor<int16_t> arm_compute::test::validation::reference::range	(	SimpleTensor< int16_t > &	dst,
		float	start,
		const size_t	num_of_elements,
		float	step
	)

range() [4/7]

template SimpleTensor<int8_t> arm_compute::test::validation::reference::range	(	SimpleTensor< int8_t > &	dst,
		float	start,
		const size_t	num_of_elements,
		float	step
	)

range() [5/7]

SimpleTensor< T > range	(	SimpleTensor< T > &	dst,
		float	start,
		const size_t	num_of_elements,
		float	step
	)

Definition at line 50 of file Range.cpp.

{
    generate_range(dst, start, num_of_elements, step);
    return dst;
}

References arm_compute::test::validation::dst, and arm_compute::cpu::step.

Referenced by format_code::check_copyright(), arm_compute::helpers::tensor_transform::compute_strided_slice_output_shape(), clang_tidy_rules::filter_clang_tidy_lines(), TestFilter::is_selected(), format_doxygen::process_comment(), and format_code::run_fix_code_formatting().

range() [6/7]

template SimpleTensor<uint16_t> arm_compute::test::validation::reference::range	(	SimpleTensor< uint16_t > &	dst,
		float	start,
		const size_t	num_of_elements,
		float	step
	)

range() [7/7]

SimpleTensor<uint8_t> arm_compute::test::validation::reference::range	(	SimpleTensor< uint8_t > &	dst,
		float	start,
		const size_t	num_of_elements,
		float	step
	)

Definition at line 57 of file Range.cpp.

{
    if(dst.data_type() == DataType::QASYMM8)
    {
        SimpleTensor<float> dst_tmp{ dst.shape(), DataType::F32, 1 };
        generate_range(dst_tmp, start, num_of_elements, step);
        return convert_to_asymmetric<uint8_t>(dst_tmp, dst.quantization_info());
    }
    generate_range(dst, start, num_of_elements, step);
    return dst;
}

References arm_compute::test::validation::dst, arm_compute::F32, arm_compute::QASYMM8, and arm_compute::cpu::step.

rdft_1d() [1/3]

template SimpleTensor<float> arm_compute::test::validation::reference::rdft_1d

(

const SimpleTensor< float > &

src

)

rdft_1d() [2/3]

template SimpleTensor<half> arm_compute::test::validation::reference::rdft_1d

(

const SimpleTensor< half > &

src

)

rdft_1d() [3/3]

SimpleTensor< T > rdft_1d

(

const SimpleTensor< T > &

src

)

Performs an one dimensional DFT on a real input.

Parameters

[in]

src

Source tensor.

Returns

Complex output of length n/2 + 1 due to symmetry.

Definition at line 313 of file DFT.cpp.

{
    return rdft_1d_core(src, FFTDirection::Forward, false);
}

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

Referenced by arm_compute::test::validation::DATA_TEST_CASE().

rdft_2d() [1/3]

template SimpleTensor<float> arm_compute::test::validation::reference::rdft_2d

(

const SimpleTensor< float > &

src

)

rdft_2d() [2/3]

template SimpleTensor<half> arm_compute::test::validation::reference::rdft_2d

(

const SimpleTensor< half > &

src

)

rdft_2d() [3/3]

SimpleTensor< T > rdft_2d

(

const SimpleTensor< T > &

src

)

Performs a two dimensional DFT on a real input.

Parameters

[in]

src

Source tensor.

Returns

Complex output of length n/2 + 1 across width due to symmetry and height of same size as the input.

Definition at line 342 of file DFT.cpp.

{
    ARM_COMPUTE_ERROR_ON(src.num_channels() != 1);
    constexpr FFTDirection direction = FFTDirection::Forward;
 
    auto first_pass  = rdft_1d_core(src, direction, false);
    auto transposed  = permute(first_pass, PermutationVector(1U, 0U));
    auto second_pass = dft_1d_core(transposed, direction);
    return permute(second_pass, PermutationVector(1U, 0U));
}

References ARM_COMPUTE_ERROR_ON, Forward, permute(), arm_compute::test::validation::src, and arm_compute::utils::cast::U.

Referenced by conv2d_dft().

reduction_operation() [1/6]

template SimpleTensor< int64_t > 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
	)

reduction_operation() [2/6]

template SimpleTensor< int32_t > 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
	)

reduction_operation() [3/6]

template SimpleTensor<int32_t> arm_compute::test::validation::reference::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
	)

reduction_operation() [4/6]

template SimpleTensor< int32_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
	)

Definition at line 310 of file ReductionOperation.cpp.

{
    if(src.data_type() == DataType::QASYMM8_SIGNED)
    {
        // If the operation is MEAN_SUM, we can directly use the int8 implementation without taking into account scale and offset
        if(op == ReductionOperation::MEAN_SUM && src.quantization_info() == quantization_info_output)
        {
            return compute_reduction_operation<int8_t, int8_t>(src, dst_shape, axis, op, output_type, policy);
        }
        else
        {
            SimpleTensor<float> src_f = convert_from_asymmetric(src);
            SimpleTensor<float> dst_f = reference::reduction_operation<float, float>(src_f, dst_shape, axis, op, output_type);
            return convert_to_asymmetric<int8_t>(dst_f, quantization_info_output);
        }
    }
    else
    {
        return compute_reduction_operation<int8_t, int8_t>(src, dst_shape, axis, op, output_type, policy);
    }
}

References arm_compute::test::validation::convert_from_asymmetric(), arm_compute::test::validation::dst_shape, arm_compute::MEAN_SUM, arm_compute::QASYMM8_SIGNED, and arm_compute::test::validation::src.

reduction_operation() [5/6]

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
	)

Definition at line 278 of file ReductionOperation.cpp.

{
    ARM_COMPUTE_UNUSED(quantization_info_output);
    return compute_reduction_operation<T, OT>(src, dst_shape, axis, op, output_type, policy);
}

References ARM_COMPUTE_UNUSED, arm_compute::test::validation::dst_shape, and arm_compute::test::validation::src.

reduction_operation() [6/6]

template SimpleTensor< int32_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
	)

Definition at line 286 of file ReductionOperation.cpp.

{
    if(src.data_type() == DataType::QASYMM8)
    {
        // If the operation is MEAN_SUM, we can directly use the uint8 implementation without taking into account scale and offset
        if(op == ReductionOperation::MEAN_SUM && src.quantization_info() == quantization_info_output)
        {
            return compute_reduction_operation<uint8_t, uint8_t>(src, dst_shape, axis, op, output_type, policy);
        }
        else
        {
            SimpleTensor<float> src_f = convert_from_asymmetric(src);
            SimpleTensor<float> dst_f = reference::reduction_operation<float, float>(src_f, dst_shape, axis, op, output_type);
            return convert_to_asymmetric<uint8_t>(dst_f, quantization_info_output);
        }
    }
    else
    {
        return compute_reduction_operation<uint8_t, uint8_t>(src, dst_shape, axis, op, output_type, policy);
    }
}

References arm_compute::test::validation::convert_from_asymmetric(), arm_compute::test::validation::dst_shape, arm_compute::MEAN_SUM, arm_compute::QASYMM8, and arm_compute::test::validation::src.

reorder_layer() [1/2]

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

reorder_layer() [2/2]

SimpleTensor< T > reorder_layer	(	const SimpleTensor< T > &	src,
		const TensorShape &	output_shape,
		WeightFormat	output_wf
	)

Definition at line 126 of file Reorder.cpp.

{
    SimpleTensor<T> dst{ output_shape, src.data_type() };
    const int       cols = src.shape()[0];
    const int       rows = src.shape()[1];
 
    switch(output_wf)
    {
        case WeightFormat::OHWIo4:
        {
            Transform_ref<4, 1, true, sizeof(float), sizeof(float), float, arm_gemm::VLType::None>::Transform<SimpleTensor<T> &, SimpleTensor<T>>(dst, src, rows, 0, rows, 0, cols);
            break;
        }
        case WeightFormat::OHWIo8:
        {
            Transform_ref<8, 1, true, sizeof(float), sizeof(float), float, arm_gemm::VLType::None>::Transform<SimpleTensor<T> &, SimpleTensor<T>>(dst, src, rows, 0, rows, 0, cols);
            break;
        }
        default:
            break;
    }
 
    return dst;
}

References caffe_mnist_image_extractor::cols, arm_compute::test::validation::dst, arm_gemm::None, arm_compute::OHWIo4, arm_compute::OHWIo8, arm_compute::test::validation::output_shape, caffe_mnist_image_extractor::rows, and arm_compute::test::validation::src.

reorg_layer() [1/4]

template SimpleTensor<int16_t> arm_compute::test::validation::reference::reorg_layer	(	const SimpleTensor< int16_t > &	src,
		int32_t	stride
	)

reorg_layer() [2/4]

template SimpleTensor<int32_t> arm_compute::test::validation::reference::reorg_layer	(	const SimpleTensor< int32_t > &	src,
		int32_t	stride
	)

reorg_layer() [3/4]

template SimpleTensor<int8_t> arm_compute::test::validation::reference::reorg_layer	(	const SimpleTensor< int8_t > &	src,
		int32_t	stride
	)

reorg_layer() [4/4]

SimpleTensor< T > reorg_layer	(	const SimpleTensor< T > &	src,
		int32_t	stride
	)

Definition at line 38 of file ReorgLayer.cpp.

{
    ARM_COMPUTE_ERROR_ON(src.shape().num_dimensions() > 4);
    ARM_COMPUTE_ERROR_ON(src.data_layout() != DataLayout::NCHW);
 
    TensorInfo        input_info(src.shape(), 1, src.data_type());
    const TensorShape output_shape = misc::shape_calculator::compute_reorg_output_shape(input_info, stride);
 
    // Create destination tensor
    SimpleTensor<T> dst{ output_shape, src.data_type() };
 
    const unsigned int W          = dst.shape().x();
    const unsigned int H          = dst.shape().y();
    const unsigned int C          = dst.shape().z();
    const unsigned int out_c      = C / (stride * stride);
    const unsigned int outer_dims = dst.shape().total_size() / (W * H * C);
 
    // Calculate layer reorg in NCHW
    Coordinates map_coords;
 
#if defined(_OPENMP)
    #pragma omp parallel for private(map_coords)
#endif /* _OPENMP */
    for(unsigned int b = 0; b < outer_dims; ++b)
    {
        map_coords.set(3, b);
        for(unsigned int c = 0; c < C; ++c)
        {
            map_coords.set(2, c % out_c);
            const unsigned int offset = c / out_c;
            for(unsigned int h = 0; h < H; ++h)
            {
                map_coords.set(1, h * stride + offset / stride);
                for(unsigned int w = 0; w < W; ++w)
                {
                    const unsigned int dst_idx = w + W * (h + H * (c + C * b));
                    map_coords.set(0, w * stride + offset % stride);
                    dst[dst_idx] = *reinterpret_cast<const T *>(src(map_coords));
                }
            }
        }
    }
 
    return dst;
}

References ARM_COMPUTE_ERROR_ON, arm_compute::test::validation::b, arm_compute::misc::shape_calculator::compute_reorg_output_shape(), arm_compute::test::validation::dst, arm_compute::test::validation::input_info, arm_compute::NCHW, offset(), arm_compute::test::validation::output_shape, Dimensions< T >::set(), arm_compute::test::validation::src, and arm_compute::test::validation::w.

reshape_layer() [1/10]

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

reshape_layer() [2/10]

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

reshape_layer() [3/10]

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

reshape_layer() [4/10]

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

reshape_layer() [5/10]

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

reshape_layer() [6/10]

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

reshape_layer() [7/10]

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

[ReshapeLayer]

Definition at line 38 of file ReshapeLayer.cpp.

{
    ARM_COMPUTE_ERROR_ON(src.shape().total_size() != output_shape.total_size());
 
    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, arm_compute::test::validation::dst, arm_compute::test::validation::output_shape, arm_compute::test::validation::src, and TensorShape::total_size().

reshape_layer() [8/10]

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

reshape_layer() [9/10]

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

reshape_layer() [10/10]

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

reverse() [1/4]

template SimpleTensor<float> arm_compute::test::validation::reference::reverse	(	const SimpleTensor< float > &	src,
		const SimpleTensor< int32_t > &	axis,
		bool	use_inverted_axis
	)

reverse() [2/4]

template SimpleTensor<half> arm_compute::test::validation::reference::reverse	(	const SimpleTensor< half > &	src,
		const SimpleTensor< int32_t > &	axis,
		bool	use_inverted_axis
	)

reverse() [3/4]

SimpleTensor< T > reverse	(	const SimpleTensor< T > &	src,
		const SimpleTensor< int32_t > &	axis,
		bool	use_inverted_axis
	)

Definition at line 38 of file Reverse.cpp.

{
    ARM_COMPUTE_ERROR_ON(src.shape().num_dimensions() > 4);
    ARM_COMPUTE_ERROR_ON(axis.shape().num_dimensions() > 1);
    ARM_COMPUTE_ERROR_ON(axis.shape().x() > 4);
 
    // Create reference
    SimpleTensor<T> dst{ src.shape(), src.data_type(), src.num_channels(), src.quantization_info() };
 
    const unsigned int width   = src.shape()[0];
    const unsigned int height  = src.shape()[1];
    const unsigned int depth   = src.shape()[2];
    const unsigned int batches = src.shape()[3];
 
    const int rank = src.shape().num_dimensions();
 
    std::array<bool, 4> to_reverse = { { false, false, false, false } };
    for(int i = 0; i < axis.num_elements(); ++i)
    {
        int axis_i = axis[i];
 
        // The values of axis tensor must be between [-rank, rank-1].
        if((axis_i < -rank) || (axis_i >= rank))
        {
            ARM_COMPUTE_ERROR("the values of the axis tensor must be within [-rank, rank-1].");
        }
 
        // In case of negative axis value i.e targeted axis(i) = rank + axis(i)
        if(axis_i < 0)
        {
            axis_i = rank + axis_i;
        }
 
        // Reverse ACL axis indices convention i.e. (inverted)axis = (tensor_rank - 1) - axis
        if(use_inverted_axis)
        {
            axis_i = (rank - 1) - axis_i;
        }
 
        to_reverse[axis_i] = true;
    }
 
    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  src_coord = index2coord(src.shape(), i);
        const unsigned int dst_x     = to_reverse[0] ? width - src_coord[0] - 1 : src_coord[0];
        const unsigned int dst_y     = to_reverse[1] ? height - src_coord[1] - 1 : src_coord[1];
        const unsigned int dst_z     = to_reverse[2] ? depth - src_coord[2] - 1 : src_coord[2];
        const unsigned int dst_w     = to_reverse[3] ? batches - src_coord[3] - 1 : src_coord[3];
 
        dst[coord2index(src.shape(), Coordinates(dst_x, dst_y, dst_z, dst_w))] = src[i];
    }
 
    return dst;
}

References ARM_COMPUTE_ERROR, ARM_COMPUTE_ERROR_ON, batches, arm_compute::test::coord2index(), arm_compute::test::validation::dst, arm_compute::test::index2coord(), SimpleTensor< T >::num_elements(), SimpleTensor< T >::shape(), and arm_compute::test::validation::src.

Referenced by conv2d_dft(), and arm_compute::utils::parse_npy_header().

reverse() [4/4]

template SimpleTensor<uint8_t> arm_compute::test::validation::reference::reverse	(	const SimpleTensor< uint8_t > &	src,
		const SimpleTensor< int32_t > &	axis,
		bool	use_inverted_axis
	)

ridft_1d() [1/3]

template SimpleTensor<float> arm_compute::test::validation::reference::ridft_1d	(	const SimpleTensor< float > &	src,
		bool	is_odd
	)

ridft_1d() [2/3]

template SimpleTensor<half> arm_compute::test::validation::reference::ridft_1d	(	const SimpleTensor< half > &	src,
		bool	is_odd
	)

ridft_1d() [3/3]

SimpleTensor< T > ridft_1d	(	const SimpleTensor< T > &	src,
		bool	is_odd = false
	)

Performs an one dimensional inverse DFT on a real input.

Parameters

[in]	src	Source tensor.
[in]	is_odd	(Optional) Specifies if the output has odd dimensions. Is used by the inverse variant to reconstruct odd sequences.

Returns

Complex output of length n/2 + 1 due to symmetry.

Definition at line 319 of file DFT.cpp.

{
    auto dst = rdft_1d_core(src, FFTDirection::Inverse, is_odd);
 
    const T scaling_factor = T(dst.shape()[0]);
    scale(dst, scaling_factor);
 
    return dst;
}

References arm_compute::test::validation::dst, Inverse, arm_compute::test::validation::is_odd, scale(), and arm_compute::test::validation::src.

Referenced by arm_compute::test::validation::DATA_TEST_CASE().

ridft_2d() [1/3]

template SimpleTensor<float> arm_compute::test::validation::reference::ridft_2d	(	const SimpleTensor< float > &	src,
		bool	is_odd
	)

ridft_2d() [2/3]

template SimpleTensor<half> arm_compute::test::validation::reference::ridft_2d	(	const SimpleTensor< half > &	src,
		bool	is_odd
	)

ridft_2d() [3/3]

SimpleTensor< T > ridft_2d	(	const SimpleTensor< T > &	src,
		bool	is_odd = false
	)

Performs a two dimensional inverse DFT on a real input.

Parameters

[in]	src	Source tensor.
[in]	is_odd	(Optional) Specifies if the output has odd dimensions across width. Is used by the inverse variant to reconstruct odd sequences.

Returns

Complex output of length n/2 + 1 across width due to symmetry and height of same size as the input.

Definition at line 354 of file DFT.cpp.

{
    ARM_COMPUTE_ERROR_ON(src.num_channels() != 2);
    constexpr FFTDirection direction = FFTDirection::Inverse;
 
    auto transposed   = permute(src, PermutationVector(1U, 0U));
    auto first_pass   = dft_1d_core(transposed, direction);
    auto transposed_2 = permute(first_pass, PermutationVector(1U, 0U));
    auto dst          = rdft_1d_core(transposed_2, direction, is_odd);
 
    const T scaling_factor = T(dst.shape()[0] * dst.shape()[1]);
    scale(dst, scaling_factor);
    return dst;
}

References ARM_COMPUTE_ERROR_ON, arm_compute::test::validation::dst, Inverse, arm_compute::test::validation::is_odd, permute(), scale(), arm_compute::test::validation::src, and arm_compute::utils::cast::U.

Referenced by conv2d_dft().

roi_align_layer() [1/5]

SimpleTensor<float> arm_compute::test::validation::reference::roi_align_layer	(	const SimpleTensor< float > &	src,
		const SimpleTensor< float > &	rois,
		const ROIPoolingLayerInfo &	pool_info,
		const QuantizationInfo &	output_qinfo
	)

Definition at line 140 of file ROIAlignLayer.cpp.

{
    ARM_COMPUTE_UNUSED(output_qinfo);
 
    const size_t values_per_roi = rois.shape()[0];
    const size_t num_rois       = rois.shape()[1];
    DataType     dst_data_type  = src.data_type();
 
    const auto *rois_ptr = static_cast<const float *>(rois.data());
 
    TensorShape         input_shape = src.shape();
    TensorShape         output_shape(pool_info.pooled_width(), pool_info.pooled_height(), src.shape()[2], num_rois);
    SimpleTensor<float> dst(output_shape, dst_data_type);
 
    // Iterate over every pixel of the input image
    for(size_t px = 0; px < pool_info.pooled_width(); ++px)
    {
        for(size_t py = 0; py < pool_info.pooled_height(); ++py)
        {
            for(size_t pw = 0; pw < num_rois; ++pw)
            {
                const unsigned int roi_batch = rois_ptr[values_per_roi * pw];
                const auto         x1        = float(rois_ptr[values_per_roi * pw + 1]);
                const auto         y1        = float(rois_ptr[values_per_roi * pw + 2]);
                const auto         x2        = float(rois_ptr[values_per_roi * pw + 3]);
                const auto         y2        = float(rois_ptr[values_per_roi * pw + 4]);
 
                const float roi_anchor_x = x1 * pool_info.spatial_scale();
                const float roi_anchor_y = y1 * pool_info.spatial_scale();
                const float roi_dims_x   = std::max((x2 - x1) * pool_info.spatial_scale(), 1.0f);
                const float roi_dims_y   = std::max((y2 - y1) * pool_info.spatial_scale(), 1.0f);
 
                float bin_size_x     = roi_dims_x / pool_info.pooled_width();
                float bin_size_y     = roi_dims_y / pool_info.pooled_height();
                float region_start_x = px * bin_size_x + roi_anchor_x;
                float region_start_y = py * bin_size_y + roi_anchor_y;
                float region_end_x   = (px + 1) * bin_size_x + roi_anchor_x;
                float region_end_y   = (py + 1) * bin_size_y + roi_anchor_y;
 
                region_start_x = utility::clamp(region_start_x, 0.0f, float(input_shape[0]));
                region_start_y = utility::clamp(region_start_y, 0.0f, float(input_shape[1]));
                region_end_x   = utility::clamp(region_end_x, 0.0f, float(input_shape[0]));
                region_end_y   = utility::clamp(region_end_y, 0.0f, float(input_shape[1]));
 
                const int roi_bin_grid_x = (pool_info.sampling_ratio() > 0) ? pool_info.sampling_ratio() : int(ceil(bin_size_x));
                const int roi_bin_grid_y = (pool_info.sampling_ratio() > 0) ? pool_info.sampling_ratio() : int(ceil(bin_size_y));
 
                // Move input and output pointer across the fourth dimension
                const size_t input_stride_w  = input_shape[0] * input_shape[1] * input_shape[2];
                const size_t output_stride_w = output_shape[0] * output_shape[1] * output_shape[2];
                const float *input_ptr       = src.data() + roi_batch * input_stride_w;
                float       *output_ptr      = dst.data() + px + py * output_shape[0] + pw * output_stride_w;
 
                for(int pz = 0; pz < int(input_shape[2]); ++pz)
                {
                    // For every pixel pool over an aligned region
                    *(output_ptr + pz * output_shape[0] * output_shape[1]) = roi_align_1x1(input_ptr, input_shape,
                                                                                           region_start_x,
                                                                                           bin_size_x,
                                                                                           roi_bin_grid_x,
                                                                                           region_end_x,
                                                                                           region_start_y,
                                                                                           bin_size_y,
                                                                                           roi_bin_grid_y,
                                                                                           region_end_y, pz);
                }
            }
        }
    }
    return dst;
}

References ARM_COMPUTE_UNUSED, arm_compute::utility::clamp(), SimpleTensor< T >::data(), arm_compute::test::validation::dst, arm_compute::test::validation::input_shape, arm_compute::test::validation::output_shape, ROIPoolingLayerInfo::pooled_height(), ROIPoolingLayerInfo::pooled_width(), arm_compute::cpu::roi_align_1x1(), ROIPoolingLayerInfo::sampling_ratio(), SimpleTensor< T >::shape(), ROIPoolingLayerInfo::spatial_scale(), and arm_compute::test::validation::src.

roi_align_layer() [2/5]

SimpleTensor<half> arm_compute::test::validation::reference::roi_align_layer	(	const SimpleTensor< half > &	src,
		const SimpleTensor< half > &	rois,
		const ROIPoolingLayerInfo &	pool_info,
		const QuantizationInfo &	output_qinfo
	)

Definition at line 213 of file ROIAlignLayer.cpp.

{
    SimpleTensor<float> src_tmp  = float_converter<half, float>(src, DataType::F32);
    SimpleTensor<float> rois_tmp = float_converter<half, float>(rois, DataType::F32);
    SimpleTensor<float> dst_tmp  = roi_align_layer<float, float>(src_tmp, rois_tmp, pool_info, output_qinfo);
    SimpleTensor<half>  dst      = float_converter<float, half>(dst_tmp, DataType::F16);
    return dst;
}

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

roi_align_layer() [3/5]

SimpleTensor<int8_t> arm_compute::test::validation::reference::roi_align_layer	(	const SimpleTensor< int8_t > &	src,
		const SimpleTensor< uint16_t > &	rois,
		const ROIPoolingLayerInfo &	pool_info,
		const QuantizationInfo &	output_qinfo
	)

Definition at line 232 of file ROIAlignLayer.cpp.

{
    SimpleTensor<float>  src_tmp  = convert_from_asymmetric(src);
    SimpleTensor<float>  rois_tmp = convert_rois_from_asymmetric(rois);
    SimpleTensor<float>  dst_tmp  = roi_align_layer<float, float>(src_tmp, rois_tmp, pool_info, output_qinfo);
    SimpleTensor<int8_t> dst      = convert_to_asymmetric<int8_t>(dst_tmp, output_qinfo);
    return dst;
}

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

roi_align_layer() [4/5]

SimpleTensor<T> arm_compute::test::validation::reference::roi_align_layer	(	const SimpleTensor< T > &	src,
		const SimpleTensor< TRois > &	rois,
		const ROIPoolingLayerInfo &	pool_info,
		const QuantizationInfo &	output_qinfo
	)

roi_align_layer() [5/5]

SimpleTensor<uint8_t> arm_compute::test::validation::reference::roi_align_layer	(	const SimpleTensor< uint8_t > &	src,
		const SimpleTensor< uint16_t > &	rois,
		const ROIPoolingLayerInfo &	pool_info,
		const QuantizationInfo &	output_qinfo
	)

Definition at line 223 of file ROIAlignLayer.cpp.

{
    SimpleTensor<float>   src_tmp  = convert_from_asymmetric(src);
    SimpleTensor<float>   rois_tmp = convert_rois_from_asymmetric(rois);
    SimpleTensor<float>   dst_tmp  = roi_align_layer<float, float>(src_tmp, rois_tmp, pool_info, output_qinfo);
    SimpleTensor<uint8_t> dst      = convert_to_asymmetric<uint8_t>(dst_tmp, output_qinfo);
    return dst;
}

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

roi_pool_layer() [1/3]

SimpleTensor<float> arm_compute::test::validation::reference::roi_pool_layer	(	const SimpleTensor< float > &	src,
		const SimpleTensor< uint16_t > &	rois,
		const ROIPoolingLayerInfo &	pool_info,
		const QuantizationInfo &	output_qinfo
	)

Definition at line 40 of file ROIPoolingLayer.cpp.

{
    ARM_COMPUTE_UNUSED(output_qinfo);
 
    const size_t num_rois         = rois.shape()[1];
    const size_t values_per_roi   = rois.shape()[0];
    DataType     output_data_type = src.data_type();
 
    TensorShape         input_shape = src.shape();
    TensorShape         output_shape(pool_info.pooled_width(), pool_info.pooled_height(), src.shape()[2], num_rois);
    SimpleTensor<float> output(output_shape, output_data_type);
 
    const int   pooled_w      = pool_info.pooled_width();
    const int   pooled_h      = pool_info.pooled_height();
    const float spatial_scale = pool_info.spatial_scale();
 
    // get sizes of x and y dimensions in src tensor
    const int width  = src.shape()[0];
    const int height = src.shape()[1];
 
    // Move pointer across the fourth dimension
    const size_t input_stride_w  = input_shape[0] * input_shape[1] * input_shape[2];
    const size_t output_stride_w = output_shape[0] * output_shape[1] * output_shape[2];
 
    const auto *rois_ptr = reinterpret_cast<const uint16_t *>(rois.data());
 
    // Iterate through pixel width (X-Axis)
    for(size_t pw = 0; pw < num_rois; ++pw)
    {
        const unsigned int roi_batch = rois_ptr[values_per_roi * pw];
        const auto         x1        = rois_ptr[values_per_roi * pw + 1];
        const auto         y1        = rois_ptr[values_per_roi * pw + 2];
        const auto         x2        = rois_ptr[values_per_roi * pw + 3];
        const auto         y2        = rois_ptr[values_per_roi * pw + 4];
 
        //Iterate through pixel height (Y-Axis)
        for(size_t fm = 0; fm < input_shape[2]; ++fm)
        {
            // Iterate through regions of interest index
            for(size_t py = 0; py < pool_info.pooled_height(); ++py)
            {
                // Scale ROI
                const int roi_anchor_x = support::cpp11::round(x1 * spatial_scale);
                const int roi_anchor_y = support::cpp11::round(y1 * spatial_scale);
                const int roi_width    = std::max(support::cpp11::round((x2 - x1) * spatial_scale), 1.f);
                const int roi_height   = std::max(support::cpp11::round((y2 - y1) * spatial_scale), 1.f);
 
                // Iterate over feature map (Z axis)
                for(size_t px = 0; px < pool_info.pooled_width(); ++px)
                {
                    auto region_start_x = static_cast<int>(std::floor((static_cast<float>(px) / pooled_w) * roi_width));
                    auto region_end_x   = static_cast<int>(std::floor((static_cast<float>(px + 1) / pooled_w) * roi_width));
                    auto region_start_y = static_cast<int>(std::floor((static_cast<float>(py) / pooled_h) * roi_height));
                    auto region_end_y   = static_cast<int>(std::floor((static_cast<float>(py + 1) / pooled_h) * roi_height));
 
                    region_start_x = std::min(std::max(region_start_x + roi_anchor_x, 0), width);
                    region_end_x   = std::min(std::max(region_end_x + roi_anchor_x, 0), width);
                    region_start_y = std::min(std::max(region_start_y + roi_anchor_y, 0), height);
                    region_end_y   = std::min(std::max(region_end_y + roi_anchor_y, 0), height);
 
                    // Iterate through the pooling region
                    if((region_end_x <= region_start_x) || (region_end_y <= region_start_y))
                    {
                        /* Assign element in tensor 'output' at coordinates px, py, fm, roi_indx, to 0 */
                        auto out_ptr = output.data() + px + py * output_shape[0] + fm * output_shape[0] * output_shape[1] + pw * output_stride_w;
                        *out_ptr     = 0;
                    }
                    else
                    {
                        float curr_max = -std::numeric_limits<float>::max();
                        for(int j = region_start_y; j < region_end_y; ++j)
                        {
                            for(int i = region_start_x; i < region_end_x; ++i)
                            {
                                /* Retrieve element from input tensor at coordinates(i, j, fm, roi_batch) */
                                float in_element = *(src.data() + i + j * input_shape[0] + fm * input_shape[0] * input_shape[1] + roi_batch * input_stride_w);
                                curr_max         = std::max(in_element, curr_max);
                            }
                        }
 
                        /* Assign element in tensor 'output' at coordinates px, py, fm, roi_indx, to curr_max */
                        auto out_ptr = output.data() + px + py * output_shape[0] + fm * output_shape[0] * output_shape[1] + pw * output_stride_w;
                        *out_ptr     = curr_max;
                    }
                }
            }
        }
    }
 
    return output;
}

References ARM_COMPUTE_UNUSED, SimpleTensor< T >::data(), arm_compute::test::validation::input_shape, arm_compute::test::validation::output_shape, ROIPoolingLayerInfo::pooled_height(), ROIPoolingLayerInfo::pooled_width(), arm_compute::support::cpp11::round(), SimpleTensor< T >::shape(), ROIPoolingLayerInfo::spatial_scale(), and arm_compute::test::validation::src.

roi_pool_layer() [2/3]

SimpleTensor<T> arm_compute::test::validation::reference::roi_pool_layer	(	const SimpleTensor< T > &	src,
		const SimpleTensor< uint16_t > &	rois,
		const ROIPoolingLayerInfo &	pool_info,
		const QuantizationInfo &	output_qinfo
	)

roi_pool_layer() [3/3]

SimpleTensor<uint8_t> arm_compute::test::validation::reference::roi_pool_layer	(	const SimpleTensor< uint8_t > &	src,
		const SimpleTensor< uint16_t > &	rois,
		const ROIPoolingLayerInfo &	pool_info,
		const QuantizationInfo &	output_qinfo
	)

Definition at line 136 of file ROIPoolingLayer.cpp.

{
    const SimpleTensor<float> src_tmp = convert_from_asymmetric(src);
    SimpleTensor<float>       dst_tmp = roi_pool_layer<float>(src_tmp, rois, pool_info, output_qinfo);
    SimpleTensor<uint8_t>     dst     = convert_to_asymmetric<uint8_t>(dst_tmp, output_qinfo);
    return dst;
}

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

safe_read()

T arm_compute::test::validation::reference::safe_read	(	const SimpleTensor< T > &	t,
		int	y,
		int	x
	)

Definition at line 37 of file GEMMInterleaveBlocked.h.

{
    const int stride = t.shape().x();
    const int M      = t.shape().y();
    const int N      = t.shape().x();
    if((y < M) && (x < N))
    {
        return t[y * stride + x];
    }
    return 0;
}

References M, N, and tf_frozen_model_extractor::t.

Referenced by gemm_interleave_blocked().

scale() [1/6]

template SimpleTensor<float> arm_compute::test::validation::reference::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
	)

scale() [2/6]

template SimpleTensor<half> arm_compute::test::validation::reference::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
	)

scale() [3/6]

template SimpleTensor<int16_t> arm_compute::test::validation::reference::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
	)

scale() [4/6]

SimpleTensor<int8_t> arm_compute::test::validation::reference::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
	)

Definition at line 211 of file Scale.cpp.

{
    SimpleTensor<int8_t> dst;
    if(src.quantization_info().uniform().scale != 0.f)
    {
        SimpleTensor<float> src_tmp                 = convert_from_asymmetric(src);
        float               constant_border_value_f = dequantize_qasymm8_signed(constant_border_value, src.quantization_info());
        SimpleTensor<float> dst_tmp                 = scale_core<float>(src_tmp, scale_x, scale_y, policy, border_mode, constant_border_value_f, sampling_policy, ceil_policy_scale, align_corners);
        dst                                         = convert_to_asymmetric<int8_t>(dst_tmp, output_quantization_info);
    }
    else
    {
        dst = scale_core<int8_t>(src, scale_x, scale_y, policy, border_mode, constant_border_value, sampling_policy, ceil_policy_scale, align_corners);
    }
    return dst;
}

References arm_compute::test::validation::convert_from_asymmetric(), arm_compute::dequantize_qasymm8_signed(), arm_compute::test::validation::dst, arm_compute::test::validation::sampling_policy, arm_compute::test::validation::scale_x, arm_compute::test::validation::scale_y, and arm_compute::test::validation::src.

scale() [5/6]

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
	)

Definition at line 184 of file Scale.cpp.

{
    ARM_COMPUTE_UNUSED(output_quantization_info);
    return scale_core<T>(src, scale_x, scale_y, policy, border_mode, constant_border_value, sampling_policy, ceil_policy_scale, align_corners);
}

References ARM_COMPUTE_UNUSED, arm_compute::test::validation::sampling_policy, arm_compute::test::validation::scale_x, arm_compute::test::validation::scale_y, and arm_compute::test::validation::src.

Referenced by dft_1d(), dft_2d(), pixel_wise_multiplication(), ridft_1d(), and ridft_2d().

scale() [6/6]

SimpleTensor<uint8_t> arm_compute::test::validation::reference::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
	)

Definition at line 192 of file Scale.cpp.

{
    SimpleTensor<uint8_t> dst;
    if(src.quantization_info().uniform().scale != 0.f)
    {
        SimpleTensor<float> src_tmp                 = convert_from_asymmetric(src);
        float               constant_border_value_f = dequantize_qasymm8(constant_border_value, src.quantization_info());
        SimpleTensor<float> dst_tmp                 = scale_core<float>(src_tmp, scale_x, scale_y, policy, border_mode, constant_border_value_f, sampling_policy, ceil_policy_scale, align_corners);
        dst                                         = convert_to_asymmetric<uint8_t>(dst_tmp, output_quantization_info);
    }
    else
    {
        dst = scale_core<uint8_t>(src, scale_x, scale_y, policy, border_mode, constant_border_value, sampling_policy, ceil_policy_scale, align_corners);
    }
    return dst;
}

References arm_compute::test::validation::convert_from_asymmetric(), arm_compute::dequantize_qasymm8(), arm_compute::test::validation::dst, arm_compute::test::validation::sampling_policy, arm_compute::test::validation::scale_x, arm_compute::test::validation::scale_y, and arm_compute::test::validation::src.

scale_core()

SimpleTensor<T> arm_compute::test::validation::reference::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
	)

Definition at line 40 of file Scale.cpp.

{
    // Add 1 if ceil_policy_scale is true
    const size_t round_value = ceil_policy_scale ? 1U : 0U;
    TensorShape  shape_scaled(in.shape());
    shape_scaled.set(0, (in.shape()[0] + round_value) * scale_x, /* apply_dim_correction = */ false);
    shape_scaled.set(1, (in.shape()[1] + round_value) * scale_y, /* apply_dim_correction = */ false);
    SimpleTensor<T> out(shape_scaled, in.data_type());
 
    // Compute the ratio between source width/height and destination width/height
    const auto wr = arm_compute::scale_utils::calculate_resize_ratio(in.shape()[0], out.shape()[0], align_corners);
    const auto hr = arm_compute::scale_utils::calculate_resize_ratio(in.shape()[1], out.shape()[1], align_corners);
 
    const auto width  = static_cast<int>(in.shape().x());
    const auto height = static_cast<int>(in.shape().y());
 
    // Determine border size
    const int border_size = (border_mode == BorderMode::UNDEFINED) ? 0 : 1;
 
    // Area interpolation behaves as Nearest Neighbour in case of up-sampling
    if(policy == InterpolationPolicy::AREA && wr <= 1.f && hr <= 1.f)
    {
        policy = InterpolationPolicy::NEAREST_NEIGHBOR;
    }
 
    const uint32_t num_elements = out.num_elements();
    for(uint32_t element_idx = 0, count = 0; element_idx < num_elements; ++element_idx, ++count)
    {
        Coordinates id    = index2coord(out.shape(), element_idx);
        int         idx   = id.x();
        int         idy   = id.y();
        float       x_src = 0;
        float       y_src = 0;
 
        switch(policy)
        {
            case InterpolationPolicy::NEAREST_NEIGHBOR:
            {
                switch(sampling_policy)
                {
                    case SamplingPolicy::TOP_LEFT:
                        x_src = align_corners ? arm_compute::utils::rounding::round_half_away_from_zero(idx * wr) : std::floor(idx * wr);
                        y_src = align_corners ? arm_compute::utils::rounding::round_half_away_from_zero(idy * hr) : std::floor(idy * hr);
                        break;
                    case SamplingPolicy::CENTER:
                        //Calculate the source coords without -0.5f is equivalent to round the x_scr/y_src coords
                        x_src = (idx + 0.5f) * wr;
                        y_src = (idy + 0.5f) * hr;
                        break;
                    default:
                        ARM_COMPUTE_ERROR("Unsupported sampling policy.");
                }
 
                id.set(0, x_src);
                id.set(1, y_src);
 
                // If coordinates in range of tensor's width or height
                if(is_valid_pixel_index(x_src, y_src, width, height, border_size))
                {
                    out[element_idx] = tensor_elem_at(in, id, border_mode, constant_border_value);
                }
                break;
            }
            case InterpolationPolicy::BILINEAR:
            {
                switch(sampling_policy)
                {
                    case SamplingPolicy::TOP_LEFT:
                        x_src = idx * wr;
                        y_src = idy * hr;
                        break;
                    case SamplingPolicy::CENTER:
                        x_src = (idx + 0.5f) * wr - 0.5f;
                        y_src = (idy + 0.5f) * hr - 0.5f;
                        break;
                    default:
                        ARM_COMPUTE_ERROR("Unsupported sampling policy.");
                }
 
                id.set(0, std::floor(x_src));
                id.set(1, std::floor(y_src));
                if(is_valid_pixel_index(x_src, y_src, width, height, border_size))
                {
                    out[element_idx] = bilinear_policy(in, id, x_src, y_src, border_mode, constant_border_value);
                }
                else
                {
                    if(border_mode == BorderMode::CONSTANT)
                    {
                        out[element_idx] = constant_border_value;
                    }
                    else if(border_mode == BorderMode::REPLICATE)
                    {
                        id.set(0, utility::clamp<int>(x_src, 0, width - 1));
                        id.set(1, utility::clamp<int>(y_src, 0, height - 1));
                        out[element_idx] = in[coord2index(in.shape(), id)];
                    }
                }
                break;
            }
            case InterpolationPolicy::AREA:
            {
                int       x_from = std::floor(idx * wr - 0.5f - x_src);
                int       y_from = std::floor(idy * hr - 0.5f - y_src);
                int       x_to   = std::ceil((idx + 1) * wr - 0.5f - x_src);
                int       y_to   = std::ceil((idy + 1) * hr - 0.5f - y_src);
                const int xi     = std::floor(x_src);
                const int yi     = std::floor(y_src);
 
                // Clamp position to borders
                x_src = std::max(-static_cast<float>(border_size), std::min(x_src, static_cast<float>(width - 1 + border_size)));
                y_src = std::max(-static_cast<float>(border_size), std::min(y_src, static_cast<float>(height - 1 + border_size)));
 
                // Clamp bounding box offsets to borders
                x_from = ((x_src + x_from) < -border_size) ? -border_size : x_from;
                y_from = ((y_src + y_from) < -border_size) ? -border_size : y_from;
                x_to   = ((x_src + x_to) >= (width + border_size)) ? (width - 1 + border_size) : x_to;
                y_to   = ((y_src + y_to) >= (height + border_size)) ? (height - 1 + border_size) : y_to;
                ARM_COMPUTE_ERROR_ON((x_to - x_from + 1) == 0 || (y_to - y_from + 1) == 0);
 
                float sum = 0;
                for(int j = yi + y_from, je = yi + y_to; j <= je; ++j)
                {
                    for(int i = xi + x_from, ie = xi + x_to; i <= ie; ++i)
                    {
                        id.set(0, static_cast<int>(i));
                        id.set(1, static_cast<int>(j));
                        sum += tensor_elem_at(in, id, border_mode, constant_border_value);
                    }
                }
                out[element_idx] = sum / ((x_to - x_from + 1) * (y_to - y_from + 1));
 
                break;
            }
            default:
                ARM_COMPUTE_ERROR("Unsupported interpolation mode");
        }
    }
 
    return out;
}

References arm_compute::AREA, ARM_COMPUTE_ERROR, ARM_COMPUTE_ERROR_ON, arm_compute::BILINEAR, arm_compute::test::validation::bilinear_policy(), arm_compute::scale_utils::calculate_resize_ratio(), arm_compute::CENTER, arm_compute::CONSTANT, arm_compute::test::coord2index(), SimpleTensor< T >::data_type(), arm_compute::test::index2coord(), arm_compute::test::validation::is_valid_pixel_index(), arm_compute::NEAREST_NEIGHBOR, SimpleTensor< T >::num_elements(), arm_compute::REPLICATE, arm_compute::utils::rounding::round_half_away_from_zero(), arm_compute::test::validation::sampling_policy, arm_compute::test::validation::scale_x, arm_compute::test::validation::scale_y, TensorShape::set(), SimpleTensor< T >::shape(), arm_compute::test::validation::shape_scaled, arm_compute::test::validation::tensor_elem_at(), arm_compute::TOP_LEFT, arm_compute::utils::cast::U, and arm_compute::UNDEFINED.

scatter_layer() [1/9]

template SimpleTensor<float> arm_compute::test::validation::reference::scatter_layer	(	const SimpleTensor< float > &	src,
		const SimpleTensor< float > &	updates,
		const SimpleTensor< int32_t > &	indices,
		const TensorShape &	out_shape,
		const ScatterInfo &	info
	)

scatter_layer() [2/9]

template SimpleTensor<half> arm_compute::test::validation::reference::scatter_layer	(	const SimpleTensor< half > &	src,
		const SimpleTensor< half > &	updates,
		const SimpleTensor< int32_t > &	indices,
		const TensorShape &	out_shape,
		const ScatterInfo &	info
	)

scatter_layer() [3/9]

template SimpleTensor<int16_t> arm_compute::test::validation::reference::scatter_layer	(	const SimpleTensor< int16_t > &	src,
		const SimpleTensor< int16_t > &	updates,
		const SimpleTensor< int32_t > &	indices,
		const TensorShape &	out_shape,
		const ScatterInfo &	info
	)

scatter_layer() [4/9]

template SimpleTensor<int32_t> arm_compute::test::validation::reference::scatter_layer	(	const SimpleTensor< int32_t > &	src,
		const SimpleTensor< int32_t > &	updates,
		const SimpleTensor< int32_t > &	indices,
		const TensorShape &	out_shape,
		const ScatterInfo &	info
	)

scatter_layer() [5/9]

template SimpleTensor<int8_t> arm_compute::test::validation::reference::scatter_layer	(	const SimpleTensor< int8_t > &	src,
		const SimpleTensor< int8_t > &	updates,
		const SimpleTensor< int32_t > &	indices,
		const TensorShape &	out_shape,
		const ScatterInfo &	info
	)

scatter_layer() [6/9]

SimpleTensor< T > scatter_layer	(	const SimpleTensor< T > &	src,
		const SimpleTensor< T > &	updates,
		const SimpleTensor< int32_t > &	indices,
		const TensorShape &	out_shape,
		const ScatterInfo &	info
	)

Definition at line 136 of file ScatterLayer.cpp.

{
    return scatter_layer_internal<T>(src, updates, indices, out_shape, info);
}

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

scatter_layer() [7/9]

template SimpleTensor<uint16_t> arm_compute::test::validation::reference::scatter_layer	(	const SimpleTensor< uint16_t > &	src,
		const SimpleTensor< uint16_t > &	updates,
		const SimpleTensor< int32_t > &	indices,
		const TensorShape &	out_shape,
		const ScatterInfo &	info
	)

scatter_layer() [8/9]

template SimpleTensor<uint32_t> arm_compute::test::validation::reference::scatter_layer	(	const SimpleTensor< uint32_t > &	src,
		const SimpleTensor< uint32_t > &	updates,
		const SimpleTensor< int32_t > &	indices,
		const TensorShape &	out_shape,
		const ScatterInfo &	info
	)

scatter_layer() [9/9]

template SimpleTensor<uint8_t> arm_compute::test::validation::reference::scatter_layer	(	const SimpleTensor< uint8_t > &	src,
		const SimpleTensor< uint8_t > &	updates,
		const SimpleTensor< int32_t > &	indices,
		const TensorShape &	out_shape,
		const ScatterInfo &	info
	)

scatter_layer_internal()

SimpleTensor< T > scatter_layer_internal	(	const SimpleTensor< T > &	src,
		const SimpleTensor< T > &	updates,
		const SimpleTensor< int32_t > &	indices,
		const TensorShape &	out_shape,
		const ScatterInfo &	info
	)

Definition at line 73 of file ScatterLayer.cpp.

{
    // 1. If zero initialization variable is false, copy src data to dst.
    SimpleTensor<T> dst{ out_shape, src.data_type(), 1 };
    if(!info.zero_initialization)
    {
        std::copy_n(src.data(), src.num_elements(), dst.data());
    }
 
    // Number of elements between each value of the dim being iterated through
    const unsigned int data_stride = updates.shape().total_size_lower(updates.shape().num_dimensions() - 1);
    const unsigned int no_output_dims = out_shape.num_dimensions();
 
    // Calculate output stride at given index for all output dims.
    std::vector<unsigned int> out_stride_at_idx(no_output_dims);
    for (unsigned int i = 0 ; i < no_output_dims; i++)
    {
        out_stride_at_idx[i] = out_shape.total_size_lower(i);
    }
 
    const unsigned int indices_x_dim = static_cast<unsigned int>(indices.shape()[0]);
    const unsigned int indices_y_dim = static_cast<unsigned int>(indices.shape()[1]);
 
    // 2. Iterate over indices tensor y-dim and replace sections of dst tensor with relevant areas of update tensor.
    for(unsigned int i = 0; i < indices_y_dim; i++)
    {
        // NOTE : Currently, indices.shape() == [X, Y, 1, 1], where  X is the indices dim and Y is the batch dim
        // Starting index for both the update and indices tensors.
        const unsigned int update_dim_start = i * data_stride;
        const unsigned int indices_dim_start = i * indices_x_dim;
        bool out_of_bounds = false;
        unsigned int out_offset_acc = 0;
 
        // Iterate over each indices value for the relevant batch and accumulate the offset.
        for(unsigned int j = 0; j < indices_x_dim; j++)
        {
            // Get first index value with i * indices_x_dim (iterating through y-dim/batch idx), then iterate through x dim by adding k
            const int index_value = indices[indices_dim_start + j];
            const unsigned int out_dim = no_output_dims - (j+1);   // Calculate corresponding output dim to current index value.
            if(index_value < static_cast<int>(out_shape[out_dim]) && index_value >= 0)
            {
                out_offset_acc += (index_value * out_stride_at_idx[out_dim]); // offset accumulation
            }
            else
            {
                out_of_bounds = true;
                break;
            }
        }
 
        // If not out of bounds, copy update tensor elements to output
        if(!out_of_bounds)
        {
            for (unsigned int j = 0 ; j < data_stride; j++)
            {
                dst[out_offset_acc + j] = reduce_op(dst[out_offset_acc + j], updates[update_dim_start + j], info.func);
            }
        }
    }
    return dst;
}

References arm_compute::test::validation::dst, arm_compute::test::validation::info, Dimensions< T >::num_dimensions(), SimpleTensor< T >::shape(), arm_compute::test::validation::src, and TensorShape::total_size_lower().

select() [1/4]

template SimpleTensor<float> arm_compute::test::validation::reference::select	(	const SimpleTensor< uint8_t > &	c,
		const SimpleTensor< float > &	x,
		const SimpleTensor< float > &	y
	)

select() [2/4]

template SimpleTensor<half> arm_compute::test::validation::reference::select	(	const SimpleTensor< uint8_t > &	c,
		const SimpleTensor< half > &	x,
		const SimpleTensor< half > &	y
	)

select() [3/4]

SimpleTensor< T > select	(	const SimpleTensor< uint8_t > &	c,
		const SimpleTensor< T > &	x,
		const SimpleTensor< T > &	y
	)

Definition at line 38 of file Select.cpp.

{
    // Check if condition has the same rank as c
    const bool is_same_rank = (c.shape().num_dimensions() == x.shape().num_dimensions());
 
    // Check shapes
    ARM_COMPUTE_ERROR_ON(x.shape() != y.shape());
    ARM_COMPUTE_ERROR_ON(is_same_rank && (x.shape() != c.shape()));
    ARM_COMPUTE_ERROR_ON(!is_same_rank && (c.shape().num_dimensions() > 1) && (c.shape().x() != x.shape()[x.shape().num_dimensions() - 1]));
 
    // Create reference
    SimpleTensor<T> dst{ x.shape(), x.data_type(), 1 };
 
    // Run select core
    if(is_same_rank)
    {
        for(int i = 0; i < x.num_elements(); ++i)
        {
            dst[i] = c[i] > 0 ? x[i] : y[i];
        }
    }
    else
    {
        T *output_ptr = dst.data();
 
        const int outer_size = c.num_elements();
        const int inner_size = x.num_elements() / outer_size;
        size_t    offset     = 0;
 
        for(int i = 0; i < outer_size; ++i)
        {
            const T *input_ptr = c[i] > 0 ? x.data() : y.data();
            memcpy(output_ptr + offset, input_ptr + offset, inner_size * sizeof(T));
            offset += inner_size;
        }
    }
 
    return dst;
}

References ARM_COMPUTE_ERROR_ON, SimpleTensor< T >::data(), SimpleTensor< T >::data_type(), arm_compute::test::validation::dst, is_same_rank, Dimensions< T >::num_dimensions(), SimpleTensor< T >::num_elements(), offset(), SimpleTensor< T >::shape(), and Dimensions< T >::x().

Referenced by direct_convolution_nhwc(), non_max_suppression(), pooling_layer_2_nchw_indices(), scale_bilinear_nchw(), scale_nearest_neighbour_nchw(), and transposed_convolution_nhwc().

select() [4/4]

template SimpleTensor<uint8_t> arm_compute::test::validation::reference::select	(	const SimpleTensor< uint8_t > &	c,
		const SimpleTensor< uint8_t > &	x,
		const SimpleTensor< uint8_t > &	y
	)

slice() [1/3]

template SimpleTensor<float> arm_compute::test::validation::reference::slice	(	const SimpleTensor< float > &	src,
		Coordinates	starts,
		Coordinates	ends
	)

slice() [2/3]

template SimpleTensor<half_float::half> arm_compute::test::validation::reference::slice	(	const SimpleTensor< half_float::half > &	src,
		Coordinates	starts,
		Coordinates	ends
	)

slice() [3/3]

SimpleTensor< T > slice	(	const SimpleTensor< T > &	src,
		Coordinates	starts,
		Coordinates	ends
	)

Definition at line 38 of file SliceOperations.cpp.

{
    using namespace arm_compute::helpers::tensor_transform;
 
    // Validation checks
    ARM_COMPUTE_ERROR_ON(src.shape().num_dimensions() > 4);
    ARM_COMPUTE_ERROR_ON(starts.num_dimensions() > src.shape().num_dimensions());
    ARM_COMPUTE_ERROR_ON(std::any_of(starts.cbegin(), starts.cbegin() + starts.num_dimensions(), [](int i)
    {
        return i < 0;
    }));
    ARM_COMPUTE_ERROR_ON(ends.num_dimensions() > src.shape().num_dimensions());
 
    // Get source shape
    const TensorShape &src_shape = src.shape();
 
    // Get destination shape
    TensorShape dst_shape = arm_compute::misc::shape_calculator::compute_slice_shape(src_shape, starts, ends);
 
    // Create destination tensor
    SimpleTensor<T> dst{ dst_shape, src.data_type(), 1 };
 
    // Perform slice
    Window win;
    win.use_tensor_dimensions(dst_shape);
    execute_window_loop(win, [&](const Coordinates & id)
    {
        Coordinates offset;
        for(unsigned int i = 0; i < id.num_dimensions(); ++i)
        {
            offset.set(i, starts[i] + id[i]);
        }
        *reinterpret_cast<T *>(dst(id)) = *reinterpret_cast<const T *>(src(offset));
    });
 
    return dst;
}

References ARM_COMPUTE_ERROR_ON, Dimensions< T >::cbegin(), arm_compute::misc::shape_calculator::compute_slice_shape(), arm_compute::test::validation::dst, arm_compute::test::validation::dst_shape, arm_compute::execute_window_loop(), Dimensions< T >::num_dimensions(), offset(), arm_compute::test::validation::src, and Window::use_tensor_dimensions().

Referenced by arm_compute::cpu::batch_normalization_nchw(), NEUnstack::configure(), CLUnstack::configure(), conv2d_dft(), deconvolution_layer(), depthconcatenate_layer(), ICLSimple2DKernel::run(), ICLSimple3DKernel::run(), CLBitwiseKernel::run(), CLSelectKernel::run(), CLFFTScaleKernel::run(), CLNormalizationLayerKernel::run(), CLQLSTMLayerNormalizationKernel::run(), CLReorgLayerKernel::run(), CLTileKernel::run(), CLMeanStdDevNormalizationKernel::run(), CLMaxUnpoolingLayerKernel::run(), CLROIPoolingLayerKernel::run(), CLComparisonKernel::run(), CLFFTDigitReverseKernel::run(), CLNormalizePlanarYUVLayerKernel::run(), CLReverseKernel::run(), CLFFTRadixStageKernel::run(), CLPadLayerKernel::run(), CLBoundingBoxTransformKernel::run(), CLFillBorderKernel::run(), CLPriorBoxLayerKernel::run(), CLROIAlignLayerKernel::run(), CLDepthwiseConvolutionLayerNativeKernel::run(), CLBatchNormalizationLayerKernel::run(), ClElementwiseKernel::run_op(), ClKernelRuntime::run_op(), ClReshapeKernel::run_op(), ClTransposeKernel::run_op(), ClDequantizeKernel::run_op(), ClFloorKernel::run_op(), ClWidthConcatenate2TensorsKernel::run_op(), ClCopyKernel::run_op(), ClElementWiseUnaryKernel::run_op(), ClFillKernel::run_op(), ClQuantizeKernel::run_op(), ClScaleKernel::run_op(), ClDepthConcatenateKernel::run_op(), ClTransposedConvolutionKernel::run_op(), ClBatchConcatenateKernel::run_op(), ClActivationKernel::run_op(), ClPool2dKernel::run_op(), ClWidthConcatenate4TensorsKernel::run_op(), ClWinogradInputTransformKernel::run_op(), ClGemmReshapeLhsMatrixKernel::run_op(), ClCastKernel::run_op(), ClGemmLowpMatrixMultiplyNativeKernel::run_op(), ClGemmLowpQuantizeDownInt32ScaleByFixedPointKernel::run_op(), ClGemmLowpQuantizeDownInt32ScaleByFloatKernel::run_op(), ClGemmLowpQuantizeDownInt32ScaleKernel::run_op(), ClGemmReshapeRhsMatrixKernel::run_op(), ClIndirectConv2dAddressPrecalculationKernel::run_op(), ClWinogradOutputTransformKernel::run_op(), ClCol2ImKernel::run_op(), ClGemmLowpMatrixMultiplyReshapedKernel::run_op(), ClGemmMatrixMultiplyNativeKernel::run_op(), ClIndirectConv2dKernel::run_op(), ClGemmMatrixMultiplyReshapedOnlyRhsMMULKernel::run_op(), CLStridedSliceKernel::run_op(), ClGemmLowpOffsetContributionKernel::run_op(), ClDirectConv3dKernel::run_op(), ClDirectConv2dKernel::run_op(), ClGemmLowpMatrixMultiplyReshapedOnlyRhsMMULKernel::run_op(), ClMulKernel::run_op(), ClGemmLowpOffsetContributionOutputStageKernel::run_op(), CLFillBorderKernel::run_op(), ClGemmLowpMatrixMultiplyReshapedOnlyRhsKernel::run_op(), ClIm2ColKernel::run_op(), ClGemmMatrixMultiplyReshapedOnlyRhsKernel::run_op(), ClGemmMatrixMultiplyReshapedKernel::run_op(), ClComplexMulKernel::run_op(), Window::slide_window_slice_1D(), Window::slide_window_slice_2D(), Window::slide_window_slice_3D(), and Window::slide_window_slice_4D().

softmax_layer() [1/5]

template SimpleTensor<float> arm_compute::test::validation::reference::softmax_layer	(	const SimpleTensor< float > &	src,
		float	beta,
		int32_t	axis,
		bool	is_log
	)

softmax_layer() [2/5]

template SimpleTensor<half> arm_compute::test::validation::reference::softmax_layer	(	const SimpleTensor< half > &	src,
		float	beta,
		int32_t	axis,
		bool	is_log
	)

softmax_layer() [3/5]

template SimpleTensor<int8_t> arm_compute::test::validation::reference::softmax_layer	(	const SimpleTensor< int8_t > &	src,
		float	beta,
		int32_t	axis,
		bool	is_log
	)

softmax_layer() [4/5]

SimpleTensor< T > softmax_layer	(	const SimpleTensor< T > &	src,
		float	beta,
		int32_t	axis,
		bool	is_log
	)

Definition at line 110 of file SoftmaxLayer.cpp.

{
    return softmax_layer_generic<T>(src, beta, axis, is_log);
}

References arm_compute::test::validation::src.

softmax_layer() [5/5]

template SimpleTensor<uint8_t> arm_compute::test::validation::reference::softmax_layer	(	const SimpleTensor< uint8_t > &	src,
		float	beta,
		int32_t	axis,
		bool	is_log
	)

softmax_layer_generic() [1/3]

template SimpleTensor<float> arm_compute::test::validation::reference::softmax_layer_generic	(	const SimpleTensor< float > &	src,
		float	beta,
		int32_t	axis,
		bool	is_log
	)

softmax_layer_generic() [2/3]

template SimpleTensor<half> arm_compute::test::validation::reference::softmax_layer_generic	(	const SimpleTensor< half > &	src,
		float	beta,
		int32_t	axis,
		bool	is_log
	)

softmax_layer_generic() [3/3]

SimpleTensor< T > softmax_layer_generic	(	const SimpleTensor< T > &	src,
		float	beta,
		int32_t	axis,
		bool	is_log
	)

Definition at line 39 of file SoftmaxLayer.cpp.

{
    // Create reference
    SimpleTensor<T> dst{ src.shape(), src.data_type(), 1 };
 
    const int32_t n_dims = static_cast<int32_t>(src.shape().num_dimensions());
    ARM_COMPUTE_ERROR_ON(axis < -n_dims || axis >= n_dims);
 
    const unsigned int actual_axis = static_cast<unsigned int>(wrap_around(axis, n_dims));
    Window             window;
    window.use_tensor_dimensions(src.shape());
    const unsigned int axis_dimension = src.shape()[actual_axis];
    window.set(actual_axis, Window::Dimension(0, 1, 1));
 
    execute_window_loop(window, [&](const Coordinates & id)
    {
        // Find max along axis
        Coordinates offset(id);
        offset.set(actual_axis, 0);
        T max = *reinterpret_cast<const T *>(src(offset));
        for(unsigned int axis_id = 1; axis_id < axis_dimension; ++axis_id)
        {
            offset.set(actual_axis, axis_id);
            const T val = *reinterpret_cast<const T *>(src(offset));
            if(val > max)
            {
                max = val;
            }
        }
 
        // Regularize
        T sum(0.f);
        for(unsigned int axis_id = 0; axis_id < axis_dimension; ++axis_id)
        {
            offset.set(actual_axis, axis_id);
            const T val = *reinterpret_cast<const T *>(src(offset));
            T       res{ (val - max) *beta };
            if(is_log)
            {
                sum += std::exp(res);
            }
            else
            {
                res = std::exp(res);
                sum += res;
            }
            *reinterpret_cast<T *>(dst(offset)) = res;
        }
 
        // Normalize
        for(unsigned int axis_id = 0; axis_id < axis_dimension; ++axis_id)
        {
            offset.set(actual_axis, axis_id);
            const T val = *reinterpret_cast<const T *>(dst(offset));
            if(is_log)
            {
                *reinterpret_cast<T *>(dst(offset)) = val - static_cast<T>(std::log(sum));
            }
            else
            {
                *reinterpret_cast<T *>(dst(offset)) = val / sum;
            }
        }
    });
    return dst;
}

References ARM_COMPUTE_ERROR_ON, arm_compute::test::validation::dst, arm_compute::execute_window_loop(), offset(), Window::set(), arm_compute::test::validation::src, Window::use_tensor_dimensions(), and arm_compute::wrap_around().

space_to_batch() [1/4]

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

space_to_batch() [2/4]

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

space_to_batch() [3/4]

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

Definition at line 38 of file SpaceToBatch.cpp.

{
    SimpleTensor<T> result(dst_shape, src.data_type(), 1, src.quantization_info());
 
    const auto width_out  = static_cast<int>(dst_shape[0]);
    const auto height_out = static_cast<int>(dst_shape[1]);
    const auto batch_out  = static_cast<int>(dst_shape[3]);
 
    const auto width_in  = static_cast<int>(src.shape()[0]);
    const auto height_in = static_cast<int>(src.shape()[1]);
    const auto batch_in  = static_cast<int>(src.shape()[3]);
 
    const auto channel = static_cast<int>(src.shape()[2]);
 
    const auto block_width  = block_shape[0];
    const auto block_height = block_shape[1];
 
    const auto padding_left = paddings[0];
    const auto padding_top  = paddings[2];
 
    // Pad value must be logic zero
    const auto pad_value = is_data_type_quantized(src.data_type()) ? src.quantization_info().uniform().offset : 0;
 
    int out_pos = 0;
    for(int outB = 0; outB < batch_out; ++outB)
    {
        unsigned int inB = outB % batch_in;
 
        int shift_w = (outB / batch_in) % block_width;
        int shift_h = (outB / batch_in) / block_width;
 
        for(int c = 0; c < channel; ++c)
        {
            for(int outH = 0; outH < height_out; ++outH)
            {
                for(int outW = 0; outW < width_out; ++outW)
                {
                    const auto in_pos = ((inB * channel + c) * height_in + ((outH * block_height + shift_h) - padding_top)) * width_in + (outW * block_width + shift_w) - padding_left;
 
                    if(outH * block_height + shift_h < padding_top || outH * block_height + shift_h >= padding_top + height_in || outW * block_width + shift_w < padding_left
                       || outW * block_width + shift_w >= padding_left + width_in)
                    {
                        result[out_pos] = pad_value;
                    }
                    else
                    {
                        result[out_pos] = src[in_pos];
                    }
                    ++out_pos;
                }
            }
        }
    }
    return result;
}

References arm_compute::test::validation::dst_shape, arm_compute::is_data_type_quantized(), and arm_compute::test::validation::src.

space_to_batch() [4/4]

template SimpleTensor<uint8_t> arm_compute::test::validation::reference::space_to_batch	(	const SimpleTensor< uint8_t > &	src,
		const SimpleTensor< int32_t > &	block_shape,
		const SimpleTensor< int32_t > &	paddings,
		const TensorShape &	dst_shape
	)

space_to_depth() [1/3]

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

space_to_depth() [2/3]

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

space_to_depth() [3/3]

SimpleTensor< T > space_to_depth	(	const SimpleTensor< T > &	src,
		const TensorShape &	dst_shape,
		const int	block_shape
	)

Definition at line 38 of file SpaceToDepth.cpp.

{
    SimpleTensor<T> result(dst_shape, src.data_type());
 
    const auto width_out   = static_cast<int>(dst_shape[0]);
    const auto height_out  = static_cast<int>(dst_shape[1]);
    const auto channel_out = static_cast<int>(dst_shape[2]);
 
    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 = static_cast<int>(src.shape()[3]);
 
    const auto block_width  = block_shape;
    const auto block_height = block_shape;
 
    int out_pos = 0;
    for(int ba = 0; ba < batch; ++ba)
    {
        for(int outC = 0; outC < channel_out; ++outC)
        {
            unsigned int inC = outC % channel_in;
 
            int shift_w = (outC / channel_in) % block_width;
            int shift_h = (outC / channel_in) / block_width;
 
            for(int outH = 0; outH < height_out; ++outH)
            {
                for(int outW = 0; outW < width_out; ++outW)
                {
                    const auto in_pos = ((ba * channel_in + inC) * height_in + ((outH * block_height + shift_h))) * width_in + (outW * block_width + shift_w);
                    result[out_pos]   = src[in_pos];
                    ++out_pos;
                }
            }
        }
    }
    return result;
}

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

stack_layer() [1/4]

template SimpleTensor<char> arm_compute::test::validation::reference::stack_layer	(	const std::vector< SimpleTensor< char >> &	in,
		const TensorShape &	output_shape,
		DataType	data_type,
		unsigned int	axis
	)

stack_layer() [2/4]

template SimpleTensor<int> arm_compute::test::validation::reference::stack_layer	(	const std::vector< SimpleTensor< int >> &	in,
		const TensorShape &	output_shape,
		DataType	data_type,
		unsigned int	axis
	)

stack_layer() [3/4]

template SimpleTensor<short> arm_compute::test::validation::reference::stack_layer	(	const std::vector< SimpleTensor< short >> &	in,
		const TensorShape &	output_shape,
		DataType	data_type,
		unsigned int	axis
	)

stack_layer() [4/4]

SimpleTensor< T > stack_layer	(	const std::vector< SimpleTensor< T >> &	in,
		const TensorShape &	output_shape,
		DataType	data_type,
		unsigned int	axis
	)

Definition at line 41 of file StackLayer.cpp.

{
    ARM_COMPUTE_ERROR_ON(output_shape.num_dimensions() > 5);
    ARM_COMPUTE_ERROR_ON(in.size() < 2);
    ARM_COMPUTE_ERROR_ON(axis > in[0].shape().num_dimensions());
 
    SimpleTensor<T> out{ output_shape, data_type };
 
    const int width       = in[0].shape()[0];
    const int height      = in[0].shape()[1];
    const int depth       = in[0].shape()[2];
    const int batch_size  = in[0].shape()[3];
    const int num_tensors = in.size();
 
    // Array to store the input coordinates
    // i_coordinates[0] = xi, i_coordinates[1] = yi, i_coordinates[2] = zi
    // i_coordinates[3] = bi, i_coordinates[4] = i, i_coordinates[5] = 0
    // i_coordinates[5] will be always zero and used for not incrementing the output when the input has less than 4 dimensions
    std::array<int, 6> i_coordinates{ 0 };
 
    // Array of pointers used to map the output coordinates to the input ones accordingly with the axis
    // This array is initialized with &i_coordinates[5] since this will be always zero
    std::array<int *, 5> o_coordinates = { &i_coordinates[5], &i_coordinates[5], &i_coordinates[5], &i_coordinates[5], &i_coordinates[5] };
 
    // Set the axis coordinate
    o_coordinates[axis] = &i_coordinates[4];
 
    unsigned int k_shift = 0;
 
    // Map the output coordinates
    for(unsigned int k = 0; k < in[0].shape().num_dimensions(); ++k)
    {
        if(k == axis)
        {
            k_shift++;
        }
 
        o_coordinates[k + k_shift] = &i_coordinates[k];
    }
 
    // Use alias for the input coordinates
    int &xi = i_coordinates[0];
    int &yi = i_coordinates[1];
    int &zi = i_coordinates[2];
    int &bi = i_coordinates[3];
    int &i  = i_coordinates[4];
 
    // Use alias for the output coordinates
    int &xo = *(o_coordinates[0]);
    int &yo = *(o_coordinates[1]);
    int &zo = *(o_coordinates[2]);
    int &bo = *(o_coordinates[3]);
    int &wo = *(o_coordinates[4]);
 
    // Stack tensors
    for(; i < num_tensors; ++(i))
    {
        bi = 0;
        for(; bi < batch_size; ++(bi))
        {
            zi = 0;
            for(; zi < depth; ++(zi))
            {
                yi = 0;
                for(; yi < height; ++(yi))
                {
                    xi = 0;
                    for(; xi < width; ++(xi))
                    {
                        *(reinterpret_cast<T *>(out(Coordinates(xo, yo, zo, bo, wo)))) = *(reinterpret_cast<const T *>(in[i](Coordinates(xi, yi, zi, bi))));
                    }
                }
            }
        }
    }
 
    return out;
}

References ARM_COMPUTE_ERROR_ON, arm_compute::test::validation::data_type, Dimensions< T >::num_dimensions(), arm_compute::test::validation::output_shape, and arm_compute::test::validation::shape.

strided_slice() [1/3]

template SimpleTensor<float> arm_compute::test::validation::reference::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
	)

strided_slice() [2/3]

template SimpleTensor<half_float::half> arm_compute::test::validation::reference::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
	)

strided_slice() [3/3]

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
	)

Definition at line 80 of file SliceOperations.cpp.

{
    using namespace arm_compute::helpers::tensor_transform;
 
    // Validation checks
    ARM_COMPUTE_ERROR_ON(src.shape().num_dimensions() > 4);
    ARM_COMPUTE_ERROR_ON(starts.num_dimensions() > src.shape().num_dimensions());
    ARM_COMPUTE_ERROR_ON(ends.num_dimensions() > src.shape().num_dimensions());
    ARM_COMPUTE_ERROR_ON(strides.num_dimensions() > src.shape().num_dimensions());
    ARM_COMPUTE_ERROR_ON(std::any_of(strides.cbegin(), strides.cbegin() + strides.num_dimensions(), [](int i)
    {
        return i == 0;
    }));
 
    // Get source shape
    const TensorShape &src_shape = src.shape();
 
    // Get destination shape
    const TensorShape dst_shape = compute_strided_slice_output_shape(src_shape, starts, ends, strides, begin_mask, end_mask, shrink_axis_mask);
 
    // Create destination tensor
    SimpleTensor<T> dst{ dst_shape, src.data_type(), 1 };
 
    // Get coordinates
    Coordinates starts_abs{};
    Coordinates ends_abs{};
    Coordinates final_strides{};
    std::tie(starts_abs, ends_abs, final_strides) = calculate_strided_slice_coords(src_shape,
                                                                                   starts, ends, strides,
                                                                                   begin_mask, end_mask, shrink_axis_mask);
 
    // Perform strided slice
    unsigned int idx = 0;
    Window       win;
    win.use_tensor_dimensions(compute_strided_slice_output_shape(src_shape,
                                                                 starts, ends, strides,
                                                                 begin_mask, end_mask, shrink_axis_mask, true));
    execute_window_loop(win, [&](const Coordinates & id)
    {
        Coordinates offset;
        for(unsigned int i = 0; i < id.num_dimensions(); ++i)
        {
            offset.set(i, starts_abs[i] + id[i] * final_strides[i]);
        }
        dst.data()[idx++] = *reinterpret_cast<const T *>(src(offset));
    });
 
    return dst;
}

References ARM_COMPUTE_ERROR_ON, arm_compute::helpers::tensor_transform::calculate_strided_slice_coords(), Dimensions< T >::cbegin(), arm_compute::helpers::tensor_transform::compute_strided_slice_output_shape(), arm_compute::test::validation::dst, arm_compute::test::validation::dst_shape, arm_compute::execute_window_loop(), Dimensions< T >::num_dimensions(), offset(), arm_compute::test::validation::src, and Window::use_tensor_dimensions().

table_lookup() [1/3]

template SimpleTensor<int16_t> arm_compute::test::validation::reference::table_lookup	(	const SimpleTensor< int16_t > &	src,
		const std::map< int16_t, int16_t > &	rawlut
	)

table_lookup() [2/3]

SimpleTensor< T > table_lookup	(	const SimpleTensor< T > &	src,
		const std::map< T, T > &	rawlut
	)

Definition at line 37 of file TableLookup.cpp.

{
    SimpleTensor<T> result(src.shape(), src.data_type());
 
    for(int i = 0; i < src.num_elements(); ++i)
    {
        result[i] = rawlut.at(src[i]);
    }
 
    return result;
}

References arm_compute::test::validation::src.

table_lookup() [3/3]

template SimpleTensor<uint8_t> arm_compute::test::validation::reference::table_lookup	(	const SimpleTensor< uint8_t > &	src,
		const std::map< uint8_t, uint8_t > &	rawlut
	)

tile() [1/9]

template SimpleTensor<float> arm_compute::test::validation::reference::tile	(	const SimpleTensor< float > &	src,
		const Multiples &	multiples
	)

tile() [2/9]

template SimpleTensor<half> arm_compute::test::validation::reference::tile	(	const SimpleTensor< half > &	src,
		const Multiples &	multiples
	)

tile() [3/9]

template SimpleTensor<int16_t> arm_compute::test::validation::reference::tile	(	const SimpleTensor< int16_t > &	src,
		const Multiples &	multiples
	)

tile() [4/9]

template SimpleTensor<int32_t> arm_compute::test::validation::reference::tile	(	const SimpleTensor< int32_t > &	src,
		const Multiples &	multiples
	)

tile() [5/9]

template SimpleTensor<int8_t> arm_compute::test::validation::reference::tile	(	const SimpleTensor< int8_t > &	src,
		const Multiples &	multiples
	)

tile() [6/9]

SimpleTensor< T > tile	(	const SimpleTensor< T > &	src,
		const Multiples &	multiples
	)

Definition at line 38 of file Tile.cpp.

{
    // Create reference
    const auto src_shape   = src.shape();
    const auto tiled_shape = misc::shape_calculator::compute_tiled_shape(src.shape(), multiples);
 
    SimpleTensor<T> dst{ tiled_shape, src.data_type() };
 
    const uint32_t num_elements = dst.num_elements();
    for(uint32_t idx = 0; idx < num_elements; idx++)
    {
        Coordinates coord = index2coord(tiled_shape, idx);
 
        const size_t x = coord.x();
        const size_t y = coord.y();
        const size_t z = coord.z();
        const size_t w = coord[3];
 
        Coordinates src_coords{ x % src_shape[0], y % src_shape[1], z % src_shape[2], w % src_shape[3] };
        int         src_idx = coord2index(src_shape, src_coords);
 
        dst[idx] = src[src_idx];
    }
 
    return dst;
}

References arm_compute::misc::shape_calculator::compute_tiled_shape(), arm_compute::test::coord2index(), arm_compute::test::validation::dst, arm_compute::test::index2coord(), arm_compute::test::validation::src, arm_compute::test::validation::w, Dimensions< T >::x(), Dimensions< T >::y(), and Dimensions< T >::z().

Referenced by arm_compute::test::validation::get_tile().

tile() [7/9]

template SimpleTensor<uint16_t> arm_compute::test::validation::reference::tile	(	const SimpleTensor< uint16_t > &	src,
		const Multiples &	multiples
	)

tile() [8/9]

template SimpleTensor<uint32_t> arm_compute::test::validation::reference::tile	(	const SimpleTensor< uint32_t > &	src,
		const Multiples &	multiples
	)

tile() [9/9]

template SimpleTensor<uint8_t> arm_compute::test::validation::reference::tile	(	const SimpleTensor< uint8_t > &	src,
		const Multiples &	multiples
	)

transpose() [1/6]

template SimpleTensor<float> arm_compute::test::validation::reference::transpose

(

const SimpleTensor< float > &

src

)

transpose() [2/6]

template SimpleTensor<half> arm_compute::test::validation::reference::transpose

(

const SimpleTensor< half > &

src

)

transpose() [3/6]

SimpleTensor< T > transpose

(

const SimpleTensor< T > &

src

)

Definition at line 38 of file Transpose.cpp.

{
    // Make rows the columns of the original shape
    TensorShape dst_shape{ src.shape().y(), src.shape().x() };
 
    // Create reference
    SimpleTensor<T> dst{ dst_shape, src.data_type() };
 
    // Compute reference
    const uint32_t num_elements = src.num_elements();
    for(uint32_t i = 0; i < num_elements; ++i)
    {
        const Coordinates coord = index2coord(src.shape(), i);
        const Coordinates dst_coord{ coord.y(), coord.x() };
        const size_t      dst_index = coord2index(dst.shape(), dst_coord);
 
        dst[dst_index] = src[i];
    }
 
    return dst;
}

References arm_compute::test::coord2index(), arm_compute::test::validation::dst, arm_compute::test::validation::dst_shape, arm_compute::test::index2coord(), arm_compute::test::validation::src, Dimensions< T >::x(), and Dimensions< T >::y().

transpose() [4/6]

template SimpleTensor<uint16_t> arm_compute::test::validation::reference::transpose

(

const SimpleTensor< uint16_t > &

src

)

transpose() [5/6]

template SimpleTensor<uint32_t> arm_compute::test::validation::reference::transpose

(

const SimpleTensor< uint32_t > &

src

)

transpose() [6/6]

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

(

const SimpleTensor< uint8_t > &

src

)

unstack() [1/4]

template std::vector<SimpleTensor<float> > arm_compute::test::validation::reference::unstack	(	const SimpleTensor< float > &	input_tensor,
		std::vector< SimpleTensor< float >> &	output_tensors,
		int	axis
	)

unstack() [2/4]

template std::vector<SimpleTensor<half> > arm_compute::test::validation::reference::unstack	(	const SimpleTensor< half > &	input_tensor,
		std::vector< SimpleTensor< half >> &	output_tensors,
		int	axis
	)

unstack() [3/4]

std::vector< SimpleTensor< T > > unstack	(	const SimpleTensor< T > &	input_tensor,
		std::vector< SimpleTensor< T >> &	output_tensors,
		int	axis
	)

Definition at line 87 of file Unstack.cpp.

{
    // Wrap around negative values
    const unsigned int axis_u = wrap_around(axis, static_cast<int>(input_tensor.shape().num_dimensions()));
    ARM_COMPUTE_ERROR_ON(axis_u >= input_tensor.shape().num_dimensions());
    for(size_t k = 0; k < output_tensors.size(); ++k)
    {
        SimpleTensor<T>      &output    = output_tensors[k];
        const SimpleTensor<T> kth_slice = get_slice(input_tensor, axis_u, k);
        output                          = copy_tensor<T>(kth_slice);
    }
    return output_tensors;
}

References ARM_COMPUTE_ERROR_ON, SimpleTensor< T >::shape(), and arm_compute::wrap_around().

unstack() [4/4]

template std::vector<SimpleTensor<uint8_t> > arm_compute::test::validation::reference::unstack	(	const SimpleTensor< uint8_t > &	input_tensor,
		std::vector< SimpleTensor< uint8_t >> &	output_tensors,
		int	axis
	)

weights_reshape() [1/4]

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

weights_reshape() [2/4]

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

weights_reshape() [3/4]

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

Definition at line 38 of file WeightsReshape.cpp.

{
    SimpleTensor<T> dst{ dst_shape, src.data_type(), 1 };
 
    // Compute reference
    const bool   has_bias  = biases.size() > 0;
    const size_t linear_sz = src.shape().total_size_lower(3);
    const size_t group_sz  = src.shape()[3] / num_groups;
 
    for(size_t g = 0; g < num_groups; ++g)
    {
        for(size_t w = 0; w < group_sz; ++w)
        {
            const size_t curr_weight = g * group_sz + w;
 
            size_t i = 0;
            for(; i < linear_sz; ++i)
            {
                dst[coord2index(dst.shape(), Coordinates(w, i, g))] = src[curr_weight * linear_sz + i];
            }
            if(has_bias)
            {
                dst[coord2index(dst.shape(), Coordinates(w, i, g))] = static_cast<T>(biases[curr_weight]);
            }
        }
    }
 
    return dst;
}

References arm_compute::test::coord2index(), arm_compute::test::validation::dst, arm_compute::test::validation::dst_shape, arm_compute::test::validation::has_bias, arm_compute::test::validation::num_groups, SimpleTensor< T >::size(), arm_compute::test::validation::src, and arm_compute::test::validation::w.

weights_reshape() [4/4]

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

winograd_filter_transform() [1/3]

template SimpleTensor<float> arm_compute::test::validation::reference::winograd_filter_transform	(	const SimpleTensor< float > &	in,
		const TensorShape &	output_shape,
		const WinogradInfo &	winograd_info
	)

winograd_filter_transform() [2/3]

template SimpleTensor<half> arm_compute::test::validation::reference::winograd_filter_transform	(	const SimpleTensor< half > &	in,
		const TensorShape &	output_shape,
		const WinogradInfo &	winograd_info
	)

winograd_filter_transform() [3/3]

SimpleTensor< T > winograd_filter_transform	(	const SimpleTensor< T > &	in,
		const TensorShape &	output_shape,
		const WinogradInfo &	winograd_info
	)

Definition at line 360 of file Winograd.cpp.

{
    ARM_COMPUTE_ERROR_ON_MSG(in.data_layout() != DataLayout::NCHW, "Only supported NCHW data format");
 
    // Create reference
    SimpleTensor<T> out{ output_shape, in.data_type(), 1 };
 
    const Size2D output_tile_size = winograd_info.output_tile_size;
    const Size2D kernel_size      = winograd_info.kernel_size;
 
    // Calculate dimensions for the tile
    const unsigned int input_tile_w    = output_tile_size.width + kernel_size.width - 1;
    const unsigned int input_tile_h    = output_tile_size.height + kernel_size.height - 1;
    const unsigned int input_tile_area = input_tile_w * input_tile_h;
 
    // Get the maximum dimension from the filter size
    const unsigned int kernel_max_dim = std::max(kernel_size.width, kernel_size.height);
 
    // Get the maximum dimension from the input tile
    const unsigned int input_tile_max_dim = std::max(input_tile_w, input_tile_h);
 
    // Simple tensor for the input tile
    SimpleTensor<T> input_tile{ TensorShape(kernel_max_dim, kernel_max_dim), in.data_type(), 1 };
 
    // Simple tensor for the transformation matrix
    SimpleTensor<T> trans_matrix{ TensorShape(kernel_max_dim, input_tile_max_dim), in.data_type(), 1 };
 
    // Simple tensor for the transformation matrix transpose
    SimpleTensor<T> trans_matrix_transposed{ TensorShape(input_tile_max_dim, kernel_max_dim), in.data_type(), 1 };
 
    // Simple tensor for the temporary tile
    SimpleTensor<T> tmp_tile{ TensorShape(kernel_max_dim, input_tile_max_dim), in.data_type(), 1 };
 
    // Simple tensor for the output tile
    SimpleTensor<T> transf_tile{ TensorShape(input_tile_max_dim, input_tile_max_dim), in.data_type(), 1 };
 
    // Initialize matrix for the filter transform
    initialize_matrix_transform(trans_matrix, output_tile_size, kernel_size, WinogradTransformType::FILTER);
 
    // Transpose the transformation matrix
    transpose_matrix<T>(trans_matrix, trans_matrix_transposed);
 
    const int num_channels = in.shape()[2];
    const int num_filters  = in.shape()[3];
    const int num_batches  = in.shape().total_size() / (kernel_size.area() * num_channels * num_filters);
 
    // If we have a vertical filter (i.e. 1x3, 1x5,..), we need to take the elements along the y direction (step_y_transf_tile = width of the output tile)
    const int step_y_transf_tile = kernel_size.width == 1 ? input_tile_max_dim : 1;
 
    for(int n = 0; n < num_batches; ++n)
    {
        for(int w = 0; w < num_filters; ++w)
        {
            for(int z = 0; z < num_channels; ++z)
            {
                // Load the tile from the input tensor
                get_tile<T>(in, input_tile, Coordinates(0, 0, z, w, n));
 
                // First transformation
                matrix_multiply<T>(trans_matrix, input_tile, tmp_tile);
 
                // Second transformation
                matrix_multiply<T>(tmp_tile, trans_matrix_transposed, transf_tile);
 
                // Store the output tile across the channels
                const int output_offset = w + z * num_filters;
 
                // Store the values across the channels
                for(unsigned int i = 0; i < input_tile_area; ++i)
                {
                    out[output_offset + i * num_filters * num_channels] = transf_tile[i * step_y_transf_tile];
                }
            }
        }
    }
 
    return out;
}

References Size2D::area(), ARM_COMPUTE_ERROR_ON_MSG, SimpleTensor< T >::data_layout(), SimpleTensor< T >::data_type(), FILTER, Size2D::height, WinogradInfo::kernel_size, arm_compute::NCHW, arm_compute::test::validation::output_shape, WinogradInfo::output_tile_size, SimpleTensor< T >::shape(), arm_compute::test::validation::w, and Size2D::width.

winograd_input_transform() [1/3]

template SimpleTensor<float> arm_compute::test::validation::reference::winograd_input_transform	(	const SimpleTensor< float > &	in,
		const TensorShape &	output_shape,
		const WinogradInfo &	winograd_info
	)

winograd_input_transform() [2/3]

template SimpleTensor<half> arm_compute::test::validation::reference::winograd_input_transform	(	const SimpleTensor< half > &	in,
		const TensorShape &	output_shape,
		const WinogradInfo &	winograd_info
	)

winograd_input_transform() [3/3]

SimpleTensor< T > winograd_input_transform	(	const SimpleTensor< T > &	in,
		const TensorShape &	output_shape,
		const WinogradInfo &	winograd_info
	)

Definition at line 236 of file Winograd.cpp.

{
    ARM_COMPUTE_ERROR_ON(in.data_layout() != DataLayout::NCHW);
 
    const PadStrideInfo conv_info        = winograd_info.convolution_info;
    const Size2D        output_tile_size = winograd_info.output_tile_size;
    const Size2D        kernel_size      = winograd_info.kernel_size;
 
    SimpleTensor<T> out{ output_shape, in.data_type() };
 
    // Calculate dimensions for the tile
    const unsigned int tile_w = output_tile_size.width + kernel_size.width - 1;
    const unsigned int tile_h = output_tile_size.height + kernel_size.height - 1;
 
    // Get the maximum dimension from the tile size
    const unsigned int tile_max_dim = std::max(tile_w, tile_h);
 
    TensorShape tile_dims(tile_max_dim, tile_max_dim);
 
    // Simple tensor for the input tile
    SimpleTensor<T> src_tile{ tile_dims, in.data_type() };
 
    // Simple tensor for the temporary tile
    SimpleTensor<T> tmp_tile{ tile_dims, in.data_type() };
 
    // Simple tensor for the output tile
    SimpleTensor<T> dst_tile{ tile_dims, in.data_type() };
 
    // Simple tensor for the transformation matrix
    SimpleTensor<T> matrix{ tile_dims, in.data_type() };
 
    // Simple tensor for the transformation matrix transposed
    SimpleTensor<T> matrix_transposed{ tile_dims, in.data_type() };
 
    // Initialize matrix for the input transform
    initialize_matrix_transform(matrix, output_tile_size, kernel_size, WinogradTransformType::INPUT);
 
    // Transpose matrix
    transpose_matrix<T>(matrix, matrix_transposed);
 
    const int in_w        = in.shape().x();
    const int in_h        = in.shape().y();
    const int in_d        = in.shape().z();
    const int out_d       = out.shape().z();
    const int num_batches = in.shape().total_size() / (in_w * in_h * in_d);
    const int step_x      = output_tile_size.width;
    const int step_y      = output_tile_size.height;
 
    // Compute the number of output tiles along the x and y direction of size "output_tile_size"
    const Size2D num_tiles = compute_winograd_convolution_tiles(Size2D(in_w, in_h),
                                                                kernel_size,
                                                                output_tile_size,
                                                                conv_info);
 
    const int num_tiles_x = num_tiles.width;
    const int num_tiles_y = num_tiles.height;
 
    // In case of 1D convolution, the input tile has to be partially filled with zeros
    int start_x_zero = 0;
    int start_y_zero = 0;
    int end_x_zero   = 0;
    int end_y_zero   = 0;
 
    if(output_tile_size.width == 1)
    {
        start_x_zero = 1;
        start_y_zero = 0;
        end_x_zero   = tile_max_dim - 1;
        end_y_zero   = tile_max_dim;
    }
    else if(output_tile_size.height == 1)
    {
        start_x_zero = 0;
        start_y_zero = 1;
        end_x_zero   = tile_max_dim;
        end_y_zero   = tile_max_dim - 1;
    }
 
    // Set the anchor and shape of the zeros area
    const Coordinates anchor_zeros(start_x_zero, start_y_zero);
    const TensorShape shape_zeros(end_x_zero, end_y_zero);
 
    // If we have a vertical filter (i.e. 1x3, 1x5,..), we need to take the elements along the y direction (step = width of the output tile)
    const int step_y_transf_tile = kernel_size.width == 1 ? tile_max_dim : 1;
 
    ARM_COMPUTE_ERROR_ON((num_tiles_x * num_tiles_y) != static_cast<int>(out.shape().y()));
 
    for(int b = 0; b < num_batches; ++b)
    {
        for(int z = 0; z < in_d; ++z)
        {
            for(int y = 0; y < num_tiles_y; ++y)
            {
                for(int x = 0; x < num_tiles_x; ++x)
                {
                    int xi = x * step_x - conv_info.pad_left();
                    int yi = y * step_y - conv_info.pad_top();
 
                    // Get the tile from the input tensor
                    get_tile<T>(in, src_tile, Coordinates(xi, yi, z, b));
 
                    // Fill partially with zeros in case of 1D convolution
                    zeros<T>(src_tile, anchor_zeros, shape_zeros);
 
                    // Compute the transformation
                    matrix_multiply<T>(matrix, src_tile, tmp_tile);
                    matrix_multiply<T>(tmp_tile, matrix_transposed, dst_tile);
 
                    // Store the output tile across the channels
                    for(int i = 0; i < out_d; ++i)
                    {
                        int xo = z;
                        int yo = x + y * num_tiles_x;
                        out[coords2index(out.shape(), Coordinates(xo, yo, i, b))] = dst_tile[i * step_y_transf_tile];
                    }
                }
            }
        }
    }
 
    return out;
}

References ARM_COMPUTE_ERROR_ON, arm_compute::test::validation::b, arm_compute::compute_winograd_convolution_tiles(), arm_compute::test::validation::conv_info, WinogradInfo::convolution_info, arm_compute::coords2index(), SimpleTensor< T >::data_layout(), SimpleTensor< T >::data_type(), Size2D::height, INPUT, WinogradInfo::kernel_size, arm_compute::NCHW, arm_compute::test::validation::output_shape, WinogradInfo::output_tile_size, SimpleTensor< T >::shape(), and Size2D::width.

Referenced by CpuWinogradConv2dTransformInputKernel::run_op().

winograd_output_transform() [1/3]

template SimpleTensor<float> arm_compute::test::validation::reference::winograd_output_transform	(	const SimpleTensor< float > &	in,
		const SimpleTensor< float > &	b,
		const TensorShape &	output_shape,
		const WinogradInfo &	winograd_info
	)

winograd_output_transform() [2/3]

template SimpleTensor<half> arm_compute::test::validation::reference::winograd_output_transform	(	const SimpleTensor< half > &	in,
		const SimpleTensor< half > &	b,
		const TensorShape &	output_shape,
		const WinogradInfo &	winograd_info
	)

winograd_output_transform() [3/3]

SimpleTensor< T > winograd_output_transform	(	const SimpleTensor< T > &	in,
		const SimpleTensor< T > &	b,
		const TensorShape &	output_shape,
		const WinogradInfo &	winograd_info
	)

Definition at line 440 of file Winograd.cpp.

{
    const PadStrideInfo conv_info        = winograd_info.convolution_info;
    const Size2D        input_dimensions = winograd_info.input_dimensions;
    const Size2D        output_tile_size = winograd_info.output_tile_size;
    const Size2D        kernel_size      = winograd_info.kernel_size;
 
    // Create reference
    SimpleTensor<T> out{ output_shape, in.data_type(), 1 };
 
    // Calculate dimensions for the tiles
    const unsigned int in_tile_w  = output_tile_size.width + kernel_size.width - 1;
    const unsigned int in_tile_h  = output_tile_size.height + kernel_size.height - 1;
    const unsigned int out_tile_w = output_tile_size.width;
    const unsigned int out_tile_h = output_tile_size.height;
 
    ARM_COMPUTE_ERROR_ON(in.shape()[2] != (in_tile_w * in_tile_h));
    ARM_COMPUTE_ERROR_ON(in.shape()[0] != out.shape()[get_data_layout_dimension_index(winograd_info.output_data_layout, DataLayoutDimension::CHANNEL)]);
 
    // Get the maximum dimension from the tile size
    const unsigned int in_tile_max_dim  = std::max(in_tile_w, in_tile_h);
    const unsigned int out_tile_max_dim = std::max(output_tile_size.width, output_tile_size.height);
 
    // Compute tile dimensions
    // Input tile dimensions
    TensorShape in_tile_dims(in_tile_max_dim, in_tile_max_dim);
 
    // Output tile dimensions
    TensorShape out_tile_dims(out_tile_max_dim, out_tile_max_dim);
 
    // Transformation matrix dimensions
    TensorShape tr_tile_dims(in_tile_max_dim, out_tile_max_dim);
 
    // Create tensors
    // Simple tensor for the input tile
    SimpleTensor<T> input_tile{ in_tile_dims, in.data_type(), 1 };
 
    // Simple tensor for the transformation matrix
    SimpleTensor<T> trans_matrix{ tr_tile_dims, in.data_type(), 1 };
 
    // Simple tensor for the transformation matrix transpose
    SimpleTensor<T> trans_matrix_transposed{ TensorShape(tr_tile_dims[1], tr_tile_dims[0]), in.data_type(), 1 };
 
    // Simple tensor for the temporary tile
    SimpleTensor<T> tmp_tile{ tr_tile_dims, in.data_type(), 1 };
 
    // Simple tensor for the output tile
    SimpleTensor<T> output_tile{ out_tile_dims, in.data_type(), 1 };
 
    // Initialize matrix for the output transform
    initialize_matrix_transform(trans_matrix, output_tile_size, kernel_size, WinogradTransformType::OUTPUT);
 
    // Transpose the transformation matrix
    transpose_matrix<T>(trans_matrix, trans_matrix_transposed);
 
    const int w_in        = in.shape()[0];
    const int h_in        = in.shape()[1];
    const int c_in        = in.shape()[2];
    const int w_out       = out.shape()[0];
    const int h_out       = out.shape()[1];
    const int c_out       = out.shape()[2];
    const int num_batches = in.shape().total_size() / (w_in * h_in * c_in);
 
    // Input strides
    const int stridey_in = w_in;
    const int stridez_in = stridey_in * h_in;
    const int stridew_in = stridez_in * c_in;
 
    // Output strides
    const int stridey_out = w_out;
    const int stridez_out = stridey_out * h_out;
    const int stridew_out = stridez_out * c_out;
 
    // Compute the number of output tiles along the x and y direction of size "output_tile_size"
    const Size2D num_tiles = compute_winograd_convolution_tiles(Size2D(input_dimensions.width, input_dimensions.height),
                                                                kernel_size,
                                                                output_tile_size,
                                                                conv_info);
 
    const int num_tiles_x = num_tiles.width;
    const int num_tiles_y = num_tiles.height;
 
    ARM_COMPUTE_UNUSED(num_tiles_y);
    ARM_COMPUTE_ERROR_ON(in.shape()[1] != static_cast<unsigned int>(num_tiles_x * num_tiles_y));
 
    // If we have a vertical filter (i.e. 1x3, 1x5,..), we still need to take the elements along the x direction (step_y_transf_tile = 1)
    const int step_y_transf_tile = kernel_size.width == 1 ? 1 : output_tile.shape()[0];
 
    // Initialize with zeros the input tile
    zeros<T>(input_tile, Coordinates(0, 0), input_tile.shape());
 
    for(int n = 0; n < num_batches; ++n)
    {
        for(int y = 0; y < h_in; ++y)
        {
            for(int x = 0; x < w_in; ++x)
            {
                // Load the input tile tile across the channels of the input tensor
                for(int z = 0; z < c_in; ++z)
                {
                    input_tile[z] = in[x + (y * stridey_in) + (z * stridez_in) + (n * stridew_in)];
                }
 
                // First transformation
                matrix_multiply<T>(trans_matrix, input_tile, tmp_tile);
 
                // Second transformation
                matrix_multiply<T>(tmp_tile, trans_matrix_transposed, output_tile);
 
                // Store the output tile
                const int xo = (y % num_tiles_x) * out_tile_w;
                const int yo = (y / num_tiles_x) * out_tile_h;
                const int zo = x;
 
                const int output_offset = xo + (yo * stridey_out) + (zo * stridez_out) + (n * stridew_out);
 
                for(int yi = 0; yi < static_cast<int>(out_tile_h); ++yi)
                {
                    for(int xi = 0; xi < static_cast<int>(out_tile_w); ++xi)
                    {
                        // Check out-of-bound writes
                        if((xo + xi < w_out) && (yo + yi < h_out))
                        {
                            out[output_offset + yi * stridey_out + xi] = output_tile[xi + yi * step_y_transf_tile];
 
                            // Add bias
                            out[output_offset + yi * stridey_out + xi] += b[zo];
                        }
                    }
                }
            }
        }
    }
 
    return out;
}

References ARM_COMPUTE_ERROR_ON, ARM_COMPUTE_UNUSED, arm_compute::test::validation::b, arm_compute::CHANNEL, arm_compute::compute_winograd_convolution_tiles(), arm_compute::test::validation::conv_info, WinogradInfo::convolution_info, SimpleTensor< T >::data_type(), arm_compute::get_data_layout_dimension_index(), Size2D::height, WinogradInfo::input_dimensions, WinogradInfo::kernel_size, OUTPUT, WinogradInfo::output_data_layout, arm_compute::test::validation::output_shape, WinogradInfo::output_tile_size, SimpleTensor< T >::shape(), and Size2D::width.

Referenced by CpuWinogradConv2dTransformOutputKernel::run_op().