From 0d719442cc4e822821cdd6192a04153329f2657e Mon Sep 17 00:00:00 2001 From: Giuseppe Rossini Date: Tue, 18 Feb 2020 10:59:58 +0000 Subject: Revert "Remove tests/validate_examples and the corresponding build options" This reverts commit 35d56ec743ee04cc07e36e9a3c62089f88de5245. Change-Id: Ib370e6129f98258504db2aefcbe3495898867240 Signed-off-by: Giuseppe Rossini --- tests/validate_examples/graph_fully_connected.cpp | 315 ++++++++++++++++++++++ 1 file changed, 315 insertions(+) create mode 100644 tests/validate_examples/graph_fully_connected.cpp (limited to 'tests/validate_examples/graph_fully_connected.cpp') diff --git a/tests/validate_examples/graph_fully_connected.cpp b/tests/validate_examples/graph_fully_connected.cpp new file mode 100644 index 0000000000..645fa8b124 --- /dev/null +++ b/tests/validate_examples/graph_fully_connected.cpp @@ -0,0 +1,315 @@ +/* + * Copyright (c) 2019 ARM Limited. + * + * SPDX-License-Identifier: MIT + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to + * deal in the Software without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +#include "arm_compute/graph.h" + +#include "support/ToolchainSupport.h" + +#include "tests/NEON/Accessor.h" +#include "tests/validation/Validation.h" +#include "tests/validation/reference/FullyConnectedLayer.h" +#include "tests/validation/reference/Permute.h" + +#include "utils/CommonGraphOptions.h" +#include "utils/GraphUtils.h" +#include "utils/Utils.h" + +#include "ValidateExample.h" +#include "graph_validate_utils.h" + +#include + +using namespace arm_compute::utils; +using namespace arm_compute::graph::frontend; +using namespace arm_compute::graph_utils; +using namespace arm_compute::graph; +using namespace arm_compute; +using namespace arm_compute::test; +using namespace arm_compute::test::validation; + +namespace +{ +/** Fully connected command line options used to configure the graph examples + * + * (Similar to common options) + * The options in this object get populated when "parse()" is called on the parser used to construct it. + * The expected workflow is: + * + * CommandLineParser parser; + * CommonOptions options( parser ); + * parser.parse(argc, argv); + */ +class FullyConnectedOptions final : public CommonGraphValidateOptions +{ +public: + explicit FullyConnectedOptions(CommandLineParser &parser) noexcept + : CommonGraphValidateOptions(parser), + width(parser.add_option>("width", 3)), + batch(parser.add_option>("batch", 1)), + input_scale(parser.add_option>("input_scale", 1.0f)), + input_offset(parser.add_option>("input_offset", 0)), + weights_scale(parser.add_option>("weights_scale", 1.0f)), + weights_offset(parser.add_option>("weights_offset", 0)), + output_scale(parser.add_option>("output_scale", 1.0f)), + output_offset(parser.add_option>("output_offset", 0)), + num_outputs(parser.add_option>("num_outputs", 1)), + input_range_low(parser.add_option>("input_range_low")), + input_range_high(parser.add_option>("input_range_high")), + weights_range_low(parser.add_option>("weights_range_low")), + weights_range_high(parser.add_option>("weights_range_high")) + { + width->set_help("Set Input dimension width"); + batch->set_help("Set Input dimension batch"); + input_scale->set_help("Quantization scale from QASYMM8"); + input_offset->set_help("Quantization offset from QASYMM8"); + weights_scale->set_help("Quantization scale from QASYMM8"); + weights_offset->set_help("Quantization offset from QASYMM8"); + output_scale->set_help("Quantization scale from QASYMM8"); + output_offset->set_help("Quantization offset from QASYMM8"); + num_outputs->set_help("Number of outputs."); + input_range_low->set_help("Lower bound for input randomization range"); + input_range_high->set_help("Lower bound for input randomization range"); + weights_range_low->set_help("Lower bound for input randomization range"); + weights_range_high->set_help("Lower bound for input randomization range"); + } + + /** Fill out the supplied parameters with user supplied parameters + * + * @param[out] os Output stream. + * @param[in] common_params Example parameters to output + * + * @return None. + */ + void consume_parameters(ExampleParams &common_params) + { + common_params.input.width = width->value(); + common_params.input.batch = batch->value(); + common_params.input.quant_info = QuantizationInfo(input_scale->value(), input_offset->value()); + common_params.input.range_low = input_range_low->value(); + common_params.input.range_high = input_range_high->value(); + + common_params.weights.quant_info = QuantizationInfo(weights_scale->value(), weights_offset->value()); + common_params.weights.range_low = weights_range_low->value(); + common_params.weights.range_high = weights_range_high->value(); + + common_params.output.quant_info = QuantizationInfo(output_scale->value(), output_offset->value()); + + common_params.data_type = data_type->value(); + common_params.fully_connected.num_outputs = num_outputs->value(); + } + + void print_parameters(::std::ostream &os, const ExampleParams &common_params) override + { + os << "Threads : " << common_params.common_params.threads << std::endl; + os << "Target : " << common_params.common_params.target << std::endl; + os << "Data type : " << common_params.data_type << std::endl; + os << "Input dimensions(X,Y, Channels, Batch) : (" << common_params.input.width << "," << common_params.input.height << "," << common_params.input.fm << "," << common_params.input.batch << ")" + << std::endl; + os << "Number of outputs : " << common_params.fully_connected.num_outputs << std::endl; + } + + /** Prevent instances of this class from being copied (As this class contains pointers) */ + FullyConnectedOptions(const FullyConnectedOptions &) = delete; + /** Prevent instances of this class from being copied (As this class contains pointers) */ + FullyConnectedOptions &operator=(const FullyConnectedOptions &) = delete; + /** Allow instances of this class to be moved */ + FullyConnectedOptions(FullyConnectedOptions &&) noexcept(true) = default; + /** Allow instances of this class to be moved */ + FullyConnectedOptions &operator=(FullyConnectedOptions &&) noexcept(true) = default; + /** Default destructor */ + ~FullyConnectedOptions() override = default; + +private: + SimpleOption *width; /**< Input width */ + SimpleOption *batch; /**< Input batch */ + SimpleOption *input_scale; /**< Input Quantization scale from QASSYMM8 */ + SimpleOption *input_offset; /**< Input Quantization offset from QASSYMM8 */ + SimpleOption *weights_scale; /**< Weights Quantization scale from QASSYMM8 */ + SimpleOption *weights_offset; /**< Weights Quantization offset from QASSYMM8 */ + SimpleOption *output_scale; /**< Output Quantization scale from QASSYMM8 */ + SimpleOption *output_offset; /**< Output Quantization offset from QASSYMM8 */ + SimpleOption *num_outputs; /**< Number of outputs. */ + SimpleOption *input_range_low; /**< Lower bound for input randomization range */ + SimpleOption *input_range_high; /**< Upper bound for input randomization range */ + SimpleOption *weights_range_low; /**< Lower bound for weights randomization range */ + SimpleOption *weights_range_high; /**< Upper bound for weights randomization range */ +}; + +/** Fully Connected Layer Graph example validation accessor class */ +template +class FullyConnectedVerifyAccessor final : public VerifyAccessor +{ + using BaseClassType = VerifyAccessor; + using BaseClassType::BaseClassType; + using BaseClassType::_params; + using TBias = typename std::conditional::type, uint8_t>::value, int32_t, D>::type; + + // Inherited methods overriden: + void create_tensors(arm_compute::test::SimpleTensor &src, + arm_compute::test::SimpleTensor &weights, + arm_compute::test::SimpleTensor &bias, + ITensor &tensor) override + { + // Calculate Tensor shapes for verification + const TensorShape input_shape = TensorShape(_params.input.width, _params.input.height, _params.input.fm, _params.input.batch); + const TensorDescriptor input_descriptor = TensorDescriptor(input_shape, _params.data_type, _params.input.quant_info); + const TensorDescriptor weights_descriptor = FullyConnectedLayerNode::compute_weights_descriptor(input_descriptor, + _params.fully_connected.num_outputs, + _params.fully_connected.info, + _params.weights.quant_info); + const TensorDescriptor output_desciptor = FullyConnectedLayerNode::compute_output_descriptor(input_descriptor, _params.fully_connected.num_outputs, _params.output.quant_info); + + //Create Input tensors + src = SimpleTensor { input_descriptor.shape, _params.data_type, 1, input_descriptor.quant_info }; + weights = SimpleTensor { weights_descriptor.shape, _params.data_type, 1, weights_descriptor.quant_info }; + bias = SimpleTensor { TensorShape(tensor.info()->tensor_shape().x()), _params.data_type, 1, _params.input.quant_info }; + } + + TensorShape output_shape(ITensor &tensor) override + { + ARM_COMPUTE_UNUSED(tensor); + + const TensorShape input_shape = TensorShape(_params.input.width, _params.input.height, _params.input.fm, _params.input.batch); + const TensorDescriptor input_descriptor = TensorDescriptor(input_shape, _params.data_type, _params.input.quant_info); + const TensorDescriptor output_desciptor = FullyConnectedLayerNode::compute_output_descriptor(input_descriptor, _params.fully_connected.num_outputs, _params.output.quant_info); + + return output_desciptor.shape; + } + + arm_compute::test::SimpleTensor reference(arm_compute::test::SimpleTensor &src, + arm_compute::test::SimpleTensor &weights, + arm_compute::test::SimpleTensor &bias, + const arm_compute::TensorShape &output_shape) override + { + return reference::fully_connected_layer(src, weights, bias, output_shape, _params.output.quant_info); + } + + float relative_tolerance() override + { + const std::map> relative_tolerance + { + { + arm_compute::graph::Target::CL, + { { DataType::F16, 0.2f }, + { DataType::F32, 0.05f }, + { DataType::QASYMM8, 1.0f } + } + }, + { + arm_compute::graph::Target::NEON, + { { DataType::F16, 0.2f }, + { DataType::F32, 0.01f }, + { DataType::QASYMM8, 1.0f } + } + } + }; + + return relative_tolerance.at(_params.common_params.target).at(_params.data_type); + } + + float absolute_tolerance() override + { + const std::map> absolute_tolerance + { + { + Target::CL, + { { DataType::F16, 0.0f }, + { DataType::F32, 0.0001f }, + { DataType::QASYMM8, 1.0f } + } + }, + { + Target::NEON, + { { DataType::F16, 0.3f }, + { DataType::F32, 0.1f }, + { DataType::QASYMM8, 1.0f } + } + } + }; + + return absolute_tolerance.at(_params.common_params.target).at(_params.data_type); + } + + float tolerance_number() override + { + const std::map> absolute_tolerance + { + { + Target::CL, + { { DataType::F16, 0.07f }, + { DataType::F32, 0.07f }, + { DataType::QASYMM8, 0.0f } + } + }, + { + Target::NEON, + { { DataType::F16, 0.07f }, + { DataType::F32, 0.0f }, + { DataType::QASYMM8, 0.0f } + } + } + }; + + return absolute_tolerance.at(_params.common_params.target).at(_params.data_type); + } +}; + +} // namespace + +class GraphFullyConnectedValidateExample final : public GraphValidateExample +{ + using GraphValidateExample::graph; + +public: + GraphFullyConnectedValidateExample() + : GraphValidateExample("Fully_connected Graph example") + { + } + + FullyConnectedLayer GraphFunctionLayer(ExampleParams ¶ms) override + { + const PixelValue lower = PixelValue(params.input.range_low, params.data_type, params.input.quant_info); + const PixelValue upper = PixelValue(params.input.range_high, params.data_type, params.input.quant_info); + + const PixelValue weights_lower = PixelValue(params.weights.range_low, params.data_type, params.weights.quant_info); + const PixelValue weights_upper = PixelValue(params.weights.range_high, params.data_type, params.weights.quant_info); + + return FullyConnectedLayer(params.fully_connected.num_outputs, + get_random_accessor(weights_lower, weights_upper, 1), + get_random_accessor(lower, upper, 2), + params.fully_connected.info, params.weights.quant_info, params.output.quant_info); + } +}; + +/** Main program for Graph fully_connected test + * + * @param[in] argc Number of arguments + * @param[in] argv Arguments ( Input dimensions [width, batch] + * Fully connected [num_outputs,type] + * Verification[tolerance_number,absolute_tolerance,relative_tolerance] ) + * + */ +int main(int argc, char **argv) +{ + return arm_compute::utils::run_example(argc, argv); +} -- cgit v1.2.1