VerifyAccessor< D > Class Template Reference

Graph example validation accessor class. More...

#include <graph_validate_utils.h>

Collaboration diagram for VerifyAccessor< D >:

Public Types
using	TBias = typename std::conditional< std::is_same< typename std::decay< D >::type, uint8_t >::value, int32_t, D >::type

Public Member Functions
	VerifyAccessor (ExampleParams &params)
	Constructor. More...
bool	access_tensor (ITensor &tensor) override
	Interface to be implemented to access a given tensor. More...
virtual void	create_tensors (arm_compute::test::SimpleTensor< D > &src, arm_compute::test::SimpleTensor< D > &weights, arm_compute::test::SimpleTensor< TBias > &bias, ITensor &tensor)
	Create reference tensors. More...
virtual TensorShape	output_shape (ITensor &tensor)
	Calculate reference output tensor shape. More...
virtual arm_compute::test::SimpleTensor< D >	reference (arm_compute::test::SimpleTensor< D > &src, arm_compute::test::SimpleTensor< D > &weights, arm_compute::test::SimpleTensor< TBias > &bias, const arm_compute::TensorShape &output_shape)=0
	Calculate reference tensor. More...
void	fill_tensor (arm_compute::test::SimpleTensor< uint8_t > &tensor, std::random_device::result_type seed, uint8_t low, uint8_t high)
	Fill QASYMM tensor with Random values. More...
void	fill_tensor (arm_compute::test::SimpleTensor< int32_t > &tensor, std::random_device::result_type seed, int32_t low, int32_t high)
	Fill S32 tensor with Random values. More...
void	fill_tensor (arm_compute::test::SimpleTensor< float > &tensor, std::random_device::result_type seed, float low, float high)
	Fill F32 tensor with Random values. More...
void	fill_tensor (arm_compute::test::SimpleTensor< half > &tensor, std::random_device::result_type seed, half low, half high)
	Fill F16 tensor with Random values. More...
virtual float	relative_tolerance ()=0
	Select relative tolerance. More...
virtual float	absolute_tolerance ()=0
	Select absolute tolerance. More...
virtual float	tolerance_number ()=0
	Select tolerance number. More...
void	validate (ITensor &tensor, arm_compute::test::SimpleTensor< D > output)
	Validate the output versus the reference. More...
Public Member Functions inherited from ITensorAccessor
virtual	~ITensorAccessor ()=default
	Default virtual destructor. More...
virtual bool	access_tensor_data ()
	Returns true if the tensor data is being accessed. More...

Data Fields
ExampleParams	_params

Detailed Description

template<typename D>
class arm_compute::utils::VerifyAccessor< D >

Graph example validation accessor class.

Definition at line 346 of file graph_validate_utils.h.

Member Typedef Documentation

TBias

using TBias = typename std::conditional<std::is_same<typename std::decay<D>::type, uint8_t>::value, int32_t, D>::type

Definition at line 349 of file graph_validate_utils.h.

Constructor & Destructor Documentation

VerifyAccessor()

VerifyAccessor ( ExampleParams &  params )

inlineexplicit

Constructor.

Parameters

[in]

params

Convolution parameters

Definition at line 354 of file graph_validate_utils.h.

        : _params(std::move(params))
    {
    }

Member Function Documentation

absolute_tolerance()

virtual float absolute_tolerance ( )

pure virtual

Select absolute tolerance.

Select absolute tolerance if not supplied by user.

Returns

Appropriate absolute tolerance.

Referenced by VerifyAccessor< D >::validate().

access_tensor()

bool access_tensor ( ITensor &  tensor )

inlineoverridevirtual

Interface to be implemented to access a given tensor.

Parameters

[in]

tensor

Tensor to be accessed

Returns

True if access is successful else false

Implements ITensorAccessor.

Definition at line 359 of file graph_validate_utils.h.

    {
        if(_params.output.npy.empty())
        {
            arm_compute::test::SimpleTensor<D>     src;
            arm_compute::test::SimpleTensor<D>     weights;
            arm_compute::test::SimpleTensor<TBias> bias;
 
            //Create Input tensors
            create_tensors(src, weights, bias, tensor);
 
            //Fill the tensors with random values
            fill_tensor(src, 0, static_cast<D>(_params.input.range_low), static_cast<D>(_params.input.range_high));
            fill_tensor(weights, 1, static_cast<D>(_params.weights.range_low), static_cast<D>(_params.weights.range_high));
            fill_tensor(bias, 2, static_cast<TBias>(_params.input.range_low), static_cast<TBias>(_params.input.range_high));
 
            arm_compute::test::SimpleTensor<D> output = reference(src, weights, bias, output_shape(tensor));
 
            validate(tensor, output);
        }
        else
        {
            //The user provided a reference file use an npy accessor to validate
            arm_compute::graph_utils::NumPyAccessor(_params.output.npy, tensor.info()->tensor_shape(), tensor.info()->data_type()).access_tensor(tensor);
        }
        return false;
    }

References VerifyAccessor< D >::_params, NumPyAccessor::access_tensor(), bias, VerifyAccessor< D >::create_tensors(), VerifyAccessor< D >::fill_tensor(), CommonParams::input, TensorParams::npy, CommonParams::output, VerifyAccessor< D >::output_shape(), TensorParams::range_high, TensorParams::range_low, VerifyAccessor< D >::reference(), arm_compute::test::validation::src, tensor, VerifyAccessor< D >::validate(), and CommonParams::weights.

create_tensors()

virtual void create_tensors ( arm_compute::test::SimpleTensor< D > &  src, arm_compute::test::SimpleTensor< D > &  weights, arm_compute::test::SimpleTensor< TBias > &  bias, ITensor &  tensor  )

inlinevirtual

Create reference tensors.

Validate the given tensor against the reference result.

Parameters

[out]	src	The tensor with the source data.
[out]	weights	The tensor with the weigths data.
[out]	bias	The tensor with the bias data.
[in]	tensor	Tensor result of the actual operation passed into the Accessor.

Definition at line 397 of file graph_validate_utils.h.

    {
        ARM_COMPUTE_UNUSED(tensor);
        //Create Input tensors
        src     = arm_compute::test::SimpleTensor<D> { TensorShape(_params.input.width, _params.input.height, _params.input.fm, _params.input.batch), _params.data_type, 1, _params.input.quant_info };
        weights = arm_compute::test::SimpleTensor<D> { TensorShape(_params.weights.width, _params.weights.height, _params.weights.fm), _params.data_type, 1, _params.weights.quant_info };
        bias    = arm_compute::test::SimpleTensor<TBias> { TensorShape(_params.input.height), _params.data_type, 1, _params.input.quant_info };
    }

References VerifyAccessor< D >::_params, ARM_COMPUTE_UNUSED, TensorParams::batch, bias, CommonParams::data_type, TensorParams::fm, TensorParams::height, CommonParams::input, TensorParams::quant_info, arm_compute::test::validation::src, tensor, CommonParams::weights, and TensorParams::width.

Referenced by VerifyAccessor< D >::access_tensor().

fill_tensor() [1/4]

void fill_tensor ( arm_compute::test::SimpleTensor< float > &  tensor, std::random_device::result_type  seed, float  low, float  high  )

inline

Fill F32 tensor with Random values.

Validate the given tensor against the reference result.

Parameters

[out]	tensor	The tensor we want to file
[in]	seed	seed for the randomization function
[in]	low	lower bound for random values
[in]	high	upper bound for random values

Definition at line 490 of file graph_validate_utils.h.

    {
        ARM_COMPUTE_ERROR_ON(tensor.data_type() != arm_compute::DataType::F32);
        std::mt19937                          gen(seed);
        std::uniform_real_distribution<float> distribution(low, high);
 
        for(int i = 0; i < tensor.num_elements(); ++i)
        {
            tensor[i] = distribution(gen);
        }
    }

References ARM_COMPUTE_ERROR_ON, arm_compute::test::validation::distribution(), arm_compute::F32, and tensor.

fill_tensor() [2/4]

void fill_tensor ( arm_compute::test::SimpleTensor< half > &  tensor, std::random_device::result_type  seed, half  low, half  high  )

inline

Fill F16 tensor with Random values.

Validate the given tensor against the reference result.

Parameters

[out]	tensor	The tensor we want to file
[in]	seed	seed for the randomization function
[in]	low	lower bound for random values
[in]	high	upper bound for random values

Definition at line 510 of file graph_validate_utils.h.

    {
        ARM_COMPUTE_ERROR_ON(tensor.data_type() != arm_compute::DataType::F16);
        std::mt19937                          gen(seed);
        std::uniform_real_distribution<float> distribution(static_cast<half>(low), static_cast<half>(high));
 
        for(int i = 0; i < tensor.num_elements(); ++i)
        {
            tensor[i] = static_cast<half>(distribution(gen));
        }
    }

References ARM_COMPUTE_ERROR_ON, arm_compute::test::validation::distribution(), arm_compute::F16, and tensor.

fill_tensor() [3/4]

void fill_tensor ( arm_compute::test::SimpleTensor< int32_t > &  tensor, std::random_device::result_type  seed, int32_t  low, int32_t  high  )

inline

Fill S32 tensor with Random values.

Validate the given tensor against the reference result.

Parameters

[out]	tensor	The tensor we want to file
[in]	seed	seed for the randomization function
[in]	low	lower bound for random values
[in]	high	upper bound for random values

Definition at line 471 of file graph_validate_utils.h.

    {
        std::mt19937                           gen(seed);
        std::uniform_int_distribution<int32_t> distribution(static_cast<int32_t>(low), static_cast<uint32_t>(high));
 
        for(int i = 0; i < tensor.num_elements(); ++i)
        {
            tensor[i] = distribution(gen);
        }
    }

References arm_compute::test::validation::distribution(), and tensor.

fill_tensor() [4/4]

void fill_tensor ( arm_compute::test::SimpleTensor< uint8_t > &  tensor, std::random_device::result_type  seed, uint8_t  low, uint8_t  high  )

inline

Fill QASYMM tensor with Random values.

Validate the given tensor against the reference result.

Parameters

[out]	tensor	The tensor we want to file
[in]	seed	seed for the randomization function
[in]	low	lower bound for random values
[in]	high	upper bound for random values

Definition at line 445 of file graph_validate_utils.h.

    {
        ARM_COMPUTE_ERROR_ON(tensor.data_type() != arm_compute::DataType::QASYMM8);
 
        const UniformQuantizationInfo qinfo = tensor.quantization_info().uniform();
 
        uint8_t qasymm8_low  = quantize_qasymm8(low, qinfo);
        uint8_t qasymm8_high = quantize_qasymm8(high, qinfo);
 
        std::mt19937                           gen(seed);
        std::uniform_int_distribution<uint8_t> distribution(qasymm8_low, qasymm8_high);
 
        for(int i = 0; i < tensor.num_elements(); ++i)
        {
            tensor[i] = quantize_qasymm8(distribution(gen), qinfo);
        }
    }

References ARM_COMPUTE_ERROR_ON, arm_compute::test::validation::distribution(), arm_compute::QASYMM8, arm_compute::test::validation::qinfo, arm_compute::quantize_qasymm8(), and tensor.

Referenced by VerifyAccessor< D >::access_tensor().

output_shape()

virtual TensorShape output_shape ( ITensor &  tensor )

inlinevirtual

Calculate reference output tensor shape.

Parameters

[in]

tensor

Tensor result of the actual operation passed into the Accessor.

Returns

output tensor shape.

Definition at line 415 of file graph_validate_utils.h.

    {
        return arm_compute::graph_utils::permute_shape(tensor.info()->tensor_shape(), _params.data_layout, DataLayout::NCHW);
    }

References VerifyAccessor< D >::_params, ExampleParams::data_layout, arm_compute::NCHW, arm_compute::graph_utils::permute_shape(), and tensor.

Referenced by VerifyAccessor< D >::access_tensor().

reference()

virtual arm_compute::test::SimpleTensor<D> reference ( arm_compute::test::SimpleTensor< D > &  src, arm_compute::test::SimpleTensor< D > &  weights, arm_compute::test::SimpleTensor< TBias > &  bias, const arm_compute::TensorShape &  output_shape  )

pure virtual

Calculate reference tensor.

Validate the given tensor against the reference result.

Parameters

[in]	src	The tensor with the source data.
[in]	weights	The tensor with the weigths data.
[in]	bias	The tensor with the bias data.
[in]	output_shape	Shape of the output tensor.

Returns

Tensor with the reference output.

Referenced by VerifyAccessor< D >::access_tensor().

relative_tolerance()

virtual float relative_tolerance ( )

pure virtual

Select relative tolerance.

Select relative tolerance if not supplied by user.

Returns

Appropriate relative tolerance.

Referenced by VerifyAccessor< D >::validate().

tolerance_number()

virtual float tolerance_number ( )

pure virtual

Select tolerance number.

Select tolerance number if not supplied by user.

Returns

Appropriate tolerance number.

Referenced by VerifyAccessor< D >::validate().

validate()

void validate ( ITensor &  tensor, arm_compute::test::SimpleTensor< D >  output  )

inline

Validate the output versus the reference.

Parameters

[in]	tensor	Tensor result of the actual operation passed into the Accessor.
[in]	output	Tensor result of the reference implementation.

< Relative tolerance

< Absolute tolerance

< Tolerance number

Definition at line 551 of file graph_validate_utils.h.

    {
        float user_relative_tolerance = _params.verification.relative_tolerance;
        float user_absolute_tolerance = _params.verification.absolute_tolerance;
        float user_tolerance_num      = _params.verification.tolerance_number;
        /* If no user input was provided override with defaults. */
        if(user_relative_tolerance == -1)
        {
            user_relative_tolerance = relative_tolerance();
        }
 
        if(user_absolute_tolerance == -1)
        {
            user_absolute_tolerance = absolute_tolerance();
        }
 
        if(user_tolerance_num == -1)
        {
            user_tolerance_num = tolerance_number();
        }
 
        const arm_compute::test::validation::RelativeTolerance<float> rel_tolerance(user_relative_tolerance); /**< Relative tolerance */
        const arm_compute::test::validation::AbsoluteTolerance<float> abs_tolerance(user_absolute_tolerance); /**< Absolute tolerance */
        const float                                                   tolerance_num(user_tolerance_num);      /**< Tolerance number */
 
        arm_compute::test::validation::validate(arm_compute::test::Accessor(tensor), output, rel_tolerance, tolerance_num, abs_tolerance);
    }

References VerifyAccessor< D >::_params, VerificationParams::absolute_tolerance, VerifyAccessor< D >::absolute_tolerance(), VerificationParams::relative_tolerance, VerifyAccessor< D >::relative_tolerance(), tensor, arm_compute::test::validation::tolerance_num, VerificationParams::tolerance_number, VerifyAccessor< D >::tolerance_number(), arm_compute::test::validation::validate(), and CommonParams::verification.

Referenced by VerifyAccessor< D >::access_tensor().

Field Documentation

_params

ExampleParams _params

Definition at line 579 of file graph_validate_utils.h.

Referenced by VerifyAccessor< D >::access_tensor(), VerifyAccessor< D >::create_tensors(), VerifyAccessor< D >::output_shape(), and VerifyAccessor< D >::validate().

---

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

• tests/validate_examples/graph_validate_utils.h