1058 lines
43 KiB
C++
1058 lines
43 KiB
C++
/*
|
|
* Copyright (c) 2017-2020 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.
|
|
*/
|
|
#ifndef ARM_COMPUTE_TEST_TENSOR_LIBRARY_H
|
|
#define ARM_COMPUTE_TEST_TENSOR_LIBRARY_H
|
|
|
|
#include "arm_compute/core/Coordinates.h"
|
|
#include "arm_compute/core/Error.h"
|
|
#include "arm_compute/core/Helpers.h"
|
|
#include "arm_compute/core/TensorInfo.h"
|
|
#include "arm_compute/core/TensorShape.h"
|
|
#include "arm_compute/core/Types.h"
|
|
#include "arm_compute/core/Window.h"
|
|
#include "support/Random.h"
|
|
#include "tests/RawTensor.h"
|
|
#include "tests/TensorCache.h"
|
|
#include "tests/Utils.h"
|
|
#include "tests/framework/Exceptions.h"
|
|
|
|
#include <algorithm>
|
|
#include <cstddef>
|
|
#include <fstream>
|
|
#include <random>
|
|
#include <string>
|
|
#include <type_traits>
|
|
#include <vector>
|
|
|
|
namespace arm_compute
|
|
{
|
|
namespace test
|
|
{
|
|
/** Factory class to create and fill tensors.
|
|
*
|
|
* Allows to initialise tensors from loaded images or by specifying the shape
|
|
* explicitly. Furthermore, provides methods to fill tensors with the content of
|
|
* loaded images or with random values.
|
|
*/
|
|
class AssetsLibrary final
|
|
{
|
|
public:
|
|
using RangePair = std::pair<float, float>;
|
|
|
|
public:
|
|
/** Initialises the library with a @p path to the assets directory.
|
|
* Furthermore, sets the seed for the random generator to @p seed.
|
|
*
|
|
* @param[in] path Path to load assets from.
|
|
* @param[in] seed Seed used to initialise the random number generator.
|
|
*/
|
|
AssetsLibrary(std::string path, std::random_device::result_type seed);
|
|
|
|
/** Path to assets directory used to initialise library.
|
|
*
|
|
* @return the path to the assets directory.
|
|
*/
|
|
std::string path() const;
|
|
|
|
/** Seed that is used to fill tensors with random values.
|
|
*
|
|
* @return the initial random seed.
|
|
*/
|
|
std::random_device::result_type seed() const;
|
|
|
|
/** Provides a tensor shape for the specified image.
|
|
*
|
|
* @param[in] name Image file used to look up the raw tensor.
|
|
*
|
|
* @return the tensor shape for the specified image.
|
|
*/
|
|
TensorShape get_image_shape(const std::string &name);
|
|
|
|
/** Provides a constant raw tensor for the specified image.
|
|
*
|
|
* @param[in] name Image file used to look up the raw tensor.
|
|
*
|
|
* @return a raw tensor for the specified image.
|
|
*/
|
|
const RawTensor &get(const std::string &name) const;
|
|
|
|
/** Provides a raw tensor for the specified image.
|
|
*
|
|
* @param[in] name Image file used to look up the raw tensor.
|
|
*
|
|
* @return a raw tensor for the specified image.
|
|
*/
|
|
RawTensor get(const std::string &name);
|
|
|
|
/** Creates an uninitialised raw tensor with the given @p data_type and @p
|
|
* num_channels. The shape is derived from the specified image.
|
|
*
|
|
* @param[in] name Image file used to initialise the tensor.
|
|
* @param[in] data_type Data type used to initialise the tensor.
|
|
* @param[in] num_channels Number of channels used to initialise the tensor.
|
|
*
|
|
* @return a raw tensor for the specified image.
|
|
*/
|
|
RawTensor get(const std::string &name, DataType data_type, int num_channels = 1) const;
|
|
|
|
/** Provides a contant raw tensor for the specified image after it has been
|
|
* converted to @p format.
|
|
*
|
|
* @param[in] name Image file used to look up the raw tensor.
|
|
* @param[in] format Format used to look up the raw tensor.
|
|
*
|
|
* @return a raw tensor for the specified image.
|
|
*/
|
|
const RawTensor &get(const std::string &name, Format format) const;
|
|
|
|
/** Provides a raw tensor for the specified image after it has been
|
|
* converted to @p format.
|
|
*
|
|
* @param[in] name Image file used to look up the raw tensor.
|
|
* @param[in] format Format used to look up the raw tensor.
|
|
*
|
|
* @return a raw tensor for the specified image.
|
|
*/
|
|
RawTensor get(const std::string &name, Format format);
|
|
|
|
/** Provides a contant raw tensor for the specified channel after it has
|
|
* been extracted form the given image.
|
|
*
|
|
* @param[in] name Image file used to look up the raw tensor.
|
|
* @param[in] channel Channel used to look up the raw tensor.
|
|
*
|
|
* @note The channel has to be unambiguous so that the format can be
|
|
* inferred automatically.
|
|
*
|
|
* @return a raw tensor for the specified image channel.
|
|
*/
|
|
const RawTensor &get(const std::string &name, Channel channel) const;
|
|
|
|
/** Provides a raw tensor for the specified channel after it has been
|
|
* extracted form the given image.
|
|
*
|
|
* @param[in] name Image file used to look up the raw tensor.
|
|
* @param[in] channel Channel used to look up the raw tensor.
|
|
*
|
|
* @note The channel has to be unambiguous so that the format can be
|
|
* inferred automatically.
|
|
*
|
|
* @return a raw tensor for the specified image channel.
|
|
*/
|
|
RawTensor get(const std::string &name, Channel channel);
|
|
|
|
/** Provides a constant raw tensor for the specified channel after it has
|
|
* been extracted form the given image formatted to @p format.
|
|
*
|
|
* @param[in] name Image file used to look up the raw tensor.
|
|
* @param[in] format Format used to look up the raw tensor.
|
|
* @param[in] channel Channel used to look up the raw tensor.
|
|
*
|
|
* @return a raw tensor for the specified image channel.
|
|
*/
|
|
const RawTensor &get(const std::string &name, Format format, Channel channel) const;
|
|
|
|
/** Provides a raw tensor for the specified channel after it has been
|
|
* extracted form the given image formatted to @p format.
|
|
*
|
|
* @param[in] name Image file used to look up the raw tensor.
|
|
* @param[in] format Format used to look up the raw tensor.
|
|
* @param[in] channel Channel used to look up the raw tensor.
|
|
*
|
|
* @return a raw tensor for the specified image channel.
|
|
*/
|
|
RawTensor get(const std::string &name, Format format, Channel channel);
|
|
|
|
/** Puts garbage values all around the tensor for testing purposes
|
|
*
|
|
* @param[in, out] tensor To be filled tensor.
|
|
* @param[in] distribution Distribution used to fill the tensor's surroundings.
|
|
* @param[in] seed_offset The offset will be added to the global seed before initialising the random generator.
|
|
*/
|
|
template <typename T, typename D>
|
|
void fill_borders_with_garbage(T &&tensor, D &&distribution, std::random_device::result_type seed_offset) const;
|
|
|
|
/** Fills the specified @p tensor with random values drawn from @p
|
|
* distribution.
|
|
*
|
|
* @param[in, out] tensor To be filled tensor.
|
|
* @param[in] distribution Distribution used to fill the tensor.
|
|
* @param[in] seed_offset The offset will be added to the global seed before initialising the random generator.
|
|
*
|
|
* @note The @p distribution has to provide operator(Generator &) which
|
|
* will be used to draw samples.
|
|
*/
|
|
template <typename T, typename D>
|
|
void fill(T &&tensor, D &&distribution, std::random_device::result_type seed_offset) const;
|
|
|
|
template <typename T, typename D>
|
|
void fill_boxes(T &&tensor, D &&distribution, std::random_device::result_type seed_offset) const;
|
|
|
|
/** Fills the specified @p raw tensor with random values drawn from @p
|
|
* distribution.
|
|
*
|
|
* @param[in, out] vec To be filled vector.
|
|
* @param[in] distribution Distribution used to fill the tensor.
|
|
* @param[in] seed_offset The offset will be added to the global seed before initialising the random generator.
|
|
*
|
|
* @note The @p distribution has to provide operator(Generator &) which
|
|
* will be used to draw samples.
|
|
*/
|
|
template <typename T, typename D>
|
|
void fill(std::vector<T> &vec, D &&distribution, std::random_device::result_type seed_offset) const;
|
|
|
|
/** Fills the specified @p raw tensor with random values drawn from @p
|
|
* distribution.
|
|
*
|
|
* @param[in, out] raw To be filled raw.
|
|
* @param[in] distribution Distribution used to fill the tensor.
|
|
* @param[in] seed_offset The offset will be added to the global seed before initialising the random generator.
|
|
*
|
|
* @note The @p distribution has to provide operator(Generator &) which
|
|
* will be used to draw samples.
|
|
*/
|
|
template <typename D>
|
|
void fill(RawTensor &raw, D &&distribution, std::random_device::result_type seed_offset) const;
|
|
|
|
/** Fills the specified @p tensor with the content of the specified image
|
|
* converted to the given format.
|
|
*
|
|
* @param[in, out] tensor To be filled tensor.
|
|
* @param[in] name Image file used to fill the tensor.
|
|
* @param[in] format Format of the image used to fill the tensor.
|
|
*
|
|
* @warning No check is performed that the specified format actually
|
|
* matches the format of the tensor.
|
|
*/
|
|
template <typename T>
|
|
void fill(T &&tensor, const std::string &name, Format format) const;
|
|
|
|
/** Fills the raw tensor with the content of the specified image
|
|
* converted to the given format.
|
|
*
|
|
* @param[in, out] raw To be filled raw tensor.
|
|
* @param[in] name Image file used to fill the tensor.
|
|
* @param[in] format Format of the image used to fill the tensor.
|
|
*
|
|
* @warning No check is performed that the specified format actually
|
|
* matches the format of the tensor.
|
|
*/
|
|
void fill(RawTensor &raw, const std::string &name, Format format) const;
|
|
|
|
/** Fills the specified @p tensor with the content of the specified channel
|
|
* extracted from the given image.
|
|
*
|
|
* @param[in, out] tensor To be filled tensor.
|
|
* @param[in] name Image file used to fill the tensor.
|
|
* @param[in] channel Channel of the image used to fill the tensor.
|
|
*
|
|
* @note The channel has to be unambiguous so that the format can be
|
|
* inferred automatically.
|
|
*
|
|
* @warning No check is performed that the specified format actually
|
|
* matches the format of the tensor.
|
|
*/
|
|
template <typename T>
|
|
void fill(T &&tensor, const std::string &name, Channel channel) const;
|
|
|
|
/** Fills the raw tensor with the content of the specified channel
|
|
* extracted from the given image.
|
|
*
|
|
* @param[in, out] raw To be filled raw tensor.
|
|
* @param[in] name Image file used to fill the tensor.
|
|
* @param[in] channel Channel of the image used to fill the tensor.
|
|
*
|
|
* @note The channel has to be unambiguous so that the format can be
|
|
* inferred automatically.
|
|
*
|
|
* @warning No check is performed that the specified format actually
|
|
* matches the format of the tensor.
|
|
*/
|
|
void fill(RawTensor &raw, const std::string &name, Channel channel) const;
|
|
|
|
/** Fills the specified @p tensor with the content of the specified channel
|
|
* extracted from the given image after it has been converted to the given
|
|
* format.
|
|
*
|
|
* @param[in, out] tensor To be filled tensor.
|
|
* @param[in] name Image file used to fill the tensor.
|
|
* @param[in] format Format of the image used to fill the tensor.
|
|
* @param[in] channel Channel of the image used to fill the tensor.
|
|
*
|
|
* @warning No check is performed that the specified format actually
|
|
* matches the format of the tensor.
|
|
*/
|
|
template <typename T>
|
|
void fill(T &&tensor, const std::string &name, Format format, Channel channel) const;
|
|
|
|
/** Fills the raw tensor with the content of the specified channel
|
|
* extracted from the given image after it has been converted to the given
|
|
* format.
|
|
*
|
|
* @param[in, out] raw To be filled raw tensor.
|
|
* @param[in] name Image file used to fill the tensor.
|
|
* @param[in] format Format of the image used to fill the tensor.
|
|
* @param[in] channel Channel of the image used to fill the tensor.
|
|
*
|
|
* @warning No check is performed that the specified format actually
|
|
* matches the format of the tensor.
|
|
*/
|
|
void fill(RawTensor &raw, const std::string &name, Format format, Channel channel) const;
|
|
|
|
/** Fills the specified @p tensor with the content of the raw tensor.
|
|
*
|
|
* @param[in, out] tensor To be filled tensor.
|
|
* @param[in] raw Raw tensor used to fill the tensor.
|
|
*
|
|
* @warning No check is performed that the specified format actually
|
|
* matches the format of the tensor.
|
|
*/
|
|
template <typename T>
|
|
void fill(T &&tensor, RawTensor raw) const;
|
|
|
|
/** Fill a tensor with uniform distribution
|
|
*
|
|
* @param[in, out] tensor To be filled tensor.
|
|
* @param[in] seed_offset The offset will be added to the global seed before initialising the random generator.
|
|
*/
|
|
template <typename T>
|
|
void fill_tensor_uniform(T &&tensor, std::random_device::result_type seed_offset) const;
|
|
|
|
/** Fill a tensor with uniform distribution
|
|
*
|
|
* @param[in, out] tensor To be filled tensor.
|
|
* @param[in] seed_offset The offset will be added to the global seed before initialising the random generator.
|
|
* @param[in] low lowest value in the range (inclusive)
|
|
* @param[in] high highest value in the range (inclusive)
|
|
*
|
|
* @note @p low and @p high must be of the same type as the data type of @p tensor
|
|
*/
|
|
template <typename T, typename D>
|
|
void fill_tensor_uniform(T &&tensor, std::random_device::result_type seed_offset, D low, D high) const;
|
|
|
|
/** Fill a tensor with uniform distribution across the specified range
|
|
*
|
|
* @param[in, out] tensor To be filled tensor.
|
|
* @param[in] seed_offset The offset will be added to the global seed before initialising the random generator.
|
|
* @param[in] excluded_range_pairs Ranges to exclude from the generator
|
|
*/
|
|
template <typename T>
|
|
void fill_tensor_uniform_ranged(T &&tensor,
|
|
std::random_device::result_type seed_offset,
|
|
const std::vector<AssetsLibrary::RangePair> &excluded_range_pairs) const;
|
|
|
|
/** Fills the specified @p tensor with data loaded from .npy (numpy binary) in specified path.
|
|
*
|
|
* @param[in, out] tensor To be filled tensor.
|
|
* @param[in] name Data file.
|
|
*
|
|
* @note The numpy array stored in the binary .npy file must be row-major in the sense that it
|
|
* must store elements within a row consecutively in the memory, then rows within a 2D slice,
|
|
* then 2D slices within a 3D slice and so on. Note that it imposes no restrictions on what
|
|
* indexing convention is used in the numpy array. That is, the numpy array can be either fortran
|
|
* style or C style as long as it adheres to the rule above.
|
|
*
|
|
* More concretely, the orders of dimensions for each style are as follows:
|
|
* C-style (numpy default):
|
|
* array[HigherDims..., Z, Y, X]
|
|
* Fortran style:
|
|
* array[X, Y, Z, HigherDims...]
|
|
*/
|
|
template <typename T>
|
|
void fill_layer_data(T &&tensor, std::string name) const;
|
|
|
|
/** Fill a tensor with a constant value
|
|
*
|
|
* @param[in, out] tensor To be filled tensor.
|
|
* @param[in] value Value to be assigned to all elements of the input tensor.
|
|
*
|
|
* @note @p value must be of the same type as the data type of @p tensor
|
|
*/
|
|
template <typename T, typename D>
|
|
void fill_tensor_value(T &&tensor, D value) const;
|
|
|
|
/** Fill a tensor with a given vector with static values.
|
|
*
|
|
* @param[in, out] tensor To be filled tensor.
|
|
* @param[in] values A vector containing values
|
|
*
|
|
* To cope with various size tensors, the vector size doens't have to be
|
|
* the same as tensor's size. If the size of the tensor is larger than the vector,
|
|
* the iterator the vector will keep iterating and wrap around. If the vector is
|
|
* larger, values located after the required size won't be used.
|
|
*/
|
|
template <typename T, typename DataType>
|
|
void fill_static_values(T &&tensor, const std::vector<DataType> &values) const;
|
|
|
|
private:
|
|
// Function prototype to convert between image formats.
|
|
using Converter = void (*)(const RawTensor &src, RawTensor &dst);
|
|
// Function prototype to extract a channel from an image.
|
|
using Extractor = void (*)(const RawTensor &src, RawTensor &dst);
|
|
// Function prototype to load an image file.
|
|
using Loader = RawTensor (*)(const std::string &path);
|
|
// Function type to generate a number to fill tensors.
|
|
template <typename ResultType>
|
|
using GeneratorFunctionType = std::function<ResultType(void)>;
|
|
|
|
const Converter &get_converter(Format src, Format dst) const;
|
|
const Converter &get_converter(DataType src, Format dst) const;
|
|
const Converter &get_converter(Format src, DataType dst) const;
|
|
const Converter &get_converter(DataType src, DataType dst) const;
|
|
const Extractor &get_extractor(Format format, Channel) const;
|
|
const Loader &get_loader(const std::string &extension) const;
|
|
|
|
/** Creates a raw tensor from the specified image.
|
|
*
|
|
* @param[in] name To be loaded image file.
|
|
*
|
|
* @note If use_single_image is true @p name is ignored and the user image
|
|
* is loaded instead.
|
|
*/
|
|
RawTensor load_image(const std::string &name) const;
|
|
|
|
/** Provides a raw tensor for the specified image and format.
|
|
*
|
|
* @param[in] name Image file used to look up the raw tensor.
|
|
* @param[in] format Format used to look up the raw tensor.
|
|
*
|
|
* If the tensor has already been requested before the cached version will
|
|
* be returned. Otherwise the tensor will be added to the cache.
|
|
*
|
|
* @note If use_single_image is true @p name is ignored and the user image
|
|
* is loaded instead.
|
|
*/
|
|
const RawTensor &find_or_create_raw_tensor(const std::string &name, Format format) const;
|
|
|
|
/** Provides a raw tensor for the specified image, format and channel.
|
|
*
|
|
* @param[in] name Image file used to look up the raw tensor.
|
|
* @param[in] format Format used to look up the raw tensor.
|
|
* @param[in] channel Channel used to look up the raw tensor.
|
|
*
|
|
* If the tensor has already been requested before the cached version will
|
|
* be returned. Otherwise the tensor will be added to the cache.
|
|
*
|
|
* @note If use_single_image is true @p name is ignored and the user image
|
|
* is loaded instead.
|
|
*/
|
|
const RawTensor &find_or_create_raw_tensor(const std::string &name, Format format, Channel channel) const;
|
|
|
|
/** Fill a tensor with a value generator function.
|
|
*
|
|
* @param[in, out] tensor To be filled tensor.
|
|
* @param[in] generate_value A function that generates values.
|
|
*/
|
|
template <typename T, typename ResultType>
|
|
void fill_with_generator(T &&tensor, const GeneratorFunctionType<ResultType> &generate_value) const;
|
|
|
|
mutable TensorCache _cache{};
|
|
mutable arm_compute::Mutex _format_lock{};
|
|
mutable arm_compute::Mutex _channel_lock{};
|
|
const std::string _library_path;
|
|
std::random_device::result_type _seed;
|
|
};
|
|
|
|
namespace detail
|
|
{
|
|
template <typename T>
|
|
inline std::vector<std::pair<T, T>> convert_range_pair(const std::vector<AssetsLibrary::RangePair> &excluded_range_pairs)
|
|
{
|
|
std::vector<std::pair<T, T>> converted;
|
|
std::transform(excluded_range_pairs.begin(),
|
|
excluded_range_pairs.end(),
|
|
std::back_inserter(converted),
|
|
[](const AssetsLibrary::RangePair & p)
|
|
{
|
|
return std::pair<T, T>(static_cast<T>(p.first), static_cast<T>(p.second));
|
|
});
|
|
return converted;
|
|
}
|
|
|
|
/* Read npy header and check the payload is suitable for the specified type and shape
|
|
*
|
|
* @param[in] stream ifstream of the npy file
|
|
* @param[in] expect_typestr Expected typestr
|
|
* @param[in] expect_shape Shape of tensor expected to receive the data
|
|
*
|
|
* @note Advances stream to the beginning of the data payload
|
|
*/
|
|
void validate_npy_header(std::ifstream &stream, const std::string &expect_typestr, const TensorShape &expect_shape);
|
|
} // namespace detail
|
|
|
|
template <typename T, typename D>
|
|
void AssetsLibrary::fill_borders_with_garbage(T &&tensor, D &&distribution, std::random_device::result_type seed_offset) const
|
|
{
|
|
const PaddingSize padding_size = tensor.padding();
|
|
|
|
Window window;
|
|
window.set(0, Window::Dimension(-padding_size.left, tensor.shape()[0] + padding_size.right, 1));
|
|
if(tensor.shape().num_dimensions() > 1)
|
|
{
|
|
window.set(1, Window::Dimension(-padding_size.top, tensor.shape()[1] + padding_size.bottom, 1));
|
|
}
|
|
|
|
std::mt19937 gen(_seed + seed_offset);
|
|
|
|
execute_window_loop(window, [&](const Coordinates & id)
|
|
{
|
|
TensorShape shape = tensor.shape();
|
|
|
|
// If outside of valid region
|
|
if(id.x() < 0 || id.x() >= static_cast<int>(shape.x()) || id.y() < 0 || id.y() >= static_cast<int>(shape.y()))
|
|
{
|
|
using ResultType = typename std::remove_reference<D>::type::result_type;
|
|
const ResultType value = distribution(gen);
|
|
void *const out_ptr = tensor(id);
|
|
store_value_with_data_type(out_ptr, value, tensor.data_type());
|
|
}
|
|
});
|
|
}
|
|
|
|
template <typename T, typename D>
|
|
void AssetsLibrary::fill_boxes(T &&tensor, D &&distribution, std::random_device::result_type seed_offset) const
|
|
{
|
|
using ResultType = typename std::remove_reference<D>::type::result_type;
|
|
std::mt19937 gen(_seed + seed_offset);
|
|
TensorShape shape(tensor.shape());
|
|
const uint32_t num_boxes = tensor.num_elements() / 4;
|
|
// Iterate over all elements
|
|
std::uniform_real_distribution<> size_dist(0.f, 1.f);
|
|
for(uint32_t element_idx = 0; element_idx < num_boxes * 4; element_idx += 4)
|
|
{
|
|
const ResultType delta = size_dist(gen);
|
|
const ResultType epsilon = size_dist(gen);
|
|
const ResultType left = distribution(gen);
|
|
const ResultType top = distribution(gen);
|
|
const ResultType right = left + delta;
|
|
const ResultType bottom = top + epsilon;
|
|
const std::tuple<ResultType, ResultType, ResultType, ResultType> box(left, top, right, bottom);
|
|
Coordinates x1 = index2coord(shape, element_idx);
|
|
Coordinates y1 = index2coord(shape, element_idx + 1);
|
|
Coordinates x2 = index2coord(shape, element_idx + 2);
|
|
Coordinates y2 = index2coord(shape, element_idx + 3);
|
|
ResultType &target_value_x1 = reinterpret_cast<ResultType *>(tensor(x1))[0];
|
|
ResultType &target_value_y1 = reinterpret_cast<ResultType *>(tensor(y1))[0];
|
|
ResultType &target_value_x2 = reinterpret_cast<ResultType *>(tensor(x2))[0];
|
|
ResultType &target_value_y2 = reinterpret_cast<ResultType *>(tensor(y2))[0];
|
|
store_value_with_data_type(&target_value_x1, std::get<0>(box), tensor.data_type());
|
|
store_value_with_data_type(&target_value_y1, std::get<1>(box), tensor.data_type());
|
|
store_value_with_data_type(&target_value_x2, std::get<2>(box), tensor.data_type());
|
|
store_value_with_data_type(&target_value_y2, std::get<3>(box), tensor.data_type());
|
|
}
|
|
fill_borders_with_garbage(tensor, distribution, seed_offset);
|
|
}
|
|
|
|
template <typename T, typename D>
|
|
void AssetsLibrary::fill(std::vector<T> &vec, D &&distribution, std::random_device::result_type seed_offset) const
|
|
{
|
|
ARM_COMPUTE_ERROR_ON_MSG(vec.empty(), "Vector must not be empty");
|
|
|
|
using ResultType = typename std::remove_reference<D>::type::result_type;
|
|
|
|
std::mt19937 gen(_seed + seed_offset);
|
|
for(size_t i = 0; i < vec.size(); ++i)
|
|
{
|
|
const ResultType value = distribution(gen);
|
|
|
|
vec[i] = value;
|
|
}
|
|
}
|
|
|
|
template <typename T, typename ResultType>
|
|
void AssetsLibrary::fill_with_generator(T &&tensor, const GeneratorFunctionType<ResultType> &generate_value) const
|
|
{
|
|
const bool is_nhwc = tensor.data_layout() == DataLayout::NHWC;
|
|
TensorShape shape(tensor.shape());
|
|
|
|
if(is_nhwc)
|
|
{
|
|
// Ensure that the equivalent tensors will be filled for both data layouts
|
|
permute(shape, PermutationVector(1U, 2U, 0U));
|
|
}
|
|
|
|
// Iterate over all elements
|
|
const uint32_t num_elements = tensor.num_elements();
|
|
for(uint32_t element_idx = 0; element_idx < num_elements; ++element_idx)
|
|
{
|
|
Coordinates id = index2coord(shape, element_idx);
|
|
|
|
if(is_nhwc)
|
|
{
|
|
// Write in the correct id for permuted shapes
|
|
permute(id, PermutationVector(2U, 0U, 1U));
|
|
}
|
|
|
|
// Iterate over all channels
|
|
for(int channel = 0; channel < tensor.num_channels(); ++channel)
|
|
{
|
|
const ResultType value = generate_value();
|
|
ResultType &target_value = reinterpret_cast<ResultType *>(tensor(id))[channel];
|
|
|
|
store_value_with_data_type(&target_value, value, tensor.data_type());
|
|
}
|
|
}
|
|
}
|
|
|
|
template <typename T, typename D>
|
|
void AssetsLibrary::fill(T &&tensor, D &&distribution, std::random_device::result_type seed_offset) const
|
|
{
|
|
using ResultType = typename std::remove_reference<D>::type::result_type;
|
|
std::mt19937 gen(_seed + seed_offset);
|
|
|
|
GeneratorFunctionType<ResultType> number_generator = [&]()
|
|
{
|
|
const ResultType value = distribution(gen);
|
|
return value;
|
|
};
|
|
|
|
fill_with_generator(tensor, number_generator);
|
|
fill_borders_with_garbage(tensor, distribution, seed_offset);
|
|
}
|
|
|
|
template <typename T, typename DataType>
|
|
void AssetsLibrary::fill_static_values(T &&tensor, const std::vector<DataType> &values) const
|
|
{
|
|
auto it = values.begin();
|
|
GeneratorFunctionType<DataType> get_next_value = [&]()
|
|
{
|
|
const DataType value = *it;
|
|
++it;
|
|
|
|
if(it == values.end())
|
|
{
|
|
it = values.begin();
|
|
}
|
|
|
|
return value;
|
|
};
|
|
|
|
fill_with_generator(tensor, get_next_value);
|
|
}
|
|
|
|
template <typename D>
|
|
void AssetsLibrary::fill(RawTensor &raw, D &&distribution, std::random_device::result_type seed_offset) const
|
|
{
|
|
std::mt19937 gen(_seed + seed_offset);
|
|
|
|
for(size_t offset = 0; offset < raw.size(); offset += raw.element_size())
|
|
{
|
|
using ResultType = typename std::remove_reference<D>::type::result_type;
|
|
const ResultType value = distribution(gen);
|
|
|
|
store_value_with_data_type(raw.data() + offset, value, raw.data_type());
|
|
}
|
|
}
|
|
|
|
template <typename T>
|
|
void AssetsLibrary::fill(T &&tensor, const std::string &name, Format format) const
|
|
{
|
|
const RawTensor &raw = get(name, format);
|
|
|
|
for(size_t offset = 0; offset < raw.size(); offset += raw.element_size())
|
|
{
|
|
const Coordinates id = index2coord(raw.shape(), offset / raw.element_size());
|
|
|
|
const RawTensor::value_type *const raw_ptr = raw.data() + offset;
|
|
const auto out_ptr = static_cast<RawTensor::value_type *>(tensor(id));
|
|
std::copy_n(raw_ptr, raw.element_size(), out_ptr);
|
|
}
|
|
}
|
|
|
|
template <typename T>
|
|
void AssetsLibrary::fill(T &&tensor, const std::string &name, Channel channel) const
|
|
{
|
|
fill(std::forward<T>(tensor), name, get_format_for_channel(channel), channel);
|
|
}
|
|
|
|
template <typename T>
|
|
void AssetsLibrary::fill(T &&tensor, const std::string &name, Format format, Channel channel) const
|
|
{
|
|
const RawTensor &raw = get(name, format, channel);
|
|
|
|
for(size_t offset = 0; offset < raw.size(); offset += raw.element_size())
|
|
{
|
|
const Coordinates id = index2coord(raw.shape(), offset / raw.element_size());
|
|
|
|
const RawTensor::value_type *const raw_ptr = raw.data() + offset;
|
|
const auto out_ptr = static_cast<RawTensor::value_type *>(tensor(id));
|
|
std::copy_n(raw_ptr, raw.element_size(), out_ptr);
|
|
}
|
|
}
|
|
|
|
template <typename T>
|
|
void AssetsLibrary::fill(T &&tensor, RawTensor raw) const
|
|
{
|
|
for(size_t offset = 0; offset < raw.size(); offset += raw.element_size())
|
|
{
|
|
const Coordinates id = index2coord(raw.shape(), offset / raw.element_size());
|
|
|
|
const RawTensor::value_type *const raw_ptr = raw.data() + offset;
|
|
const auto out_ptr = static_cast<RawTensor::value_type *>(tensor(id));
|
|
std::copy_n(raw_ptr, raw.element_size(), out_ptr);
|
|
}
|
|
}
|
|
|
|
template <typename T>
|
|
void AssetsLibrary::fill_tensor_uniform(T &&tensor, std::random_device::result_type seed_offset) const
|
|
{
|
|
switch(tensor.data_type())
|
|
{
|
|
case DataType::U8:
|
|
case DataType::QASYMM8:
|
|
{
|
|
std::uniform_int_distribution<uint8_t> distribution_u8(std::numeric_limits<uint8_t>::lowest(), std::numeric_limits<uint8_t>::max());
|
|
fill(tensor, distribution_u8, seed_offset);
|
|
break;
|
|
}
|
|
case DataType::S8:
|
|
case DataType::QSYMM8:
|
|
case DataType::QSYMM8_PER_CHANNEL:
|
|
case DataType::QASYMM8_SIGNED:
|
|
{
|
|
std::uniform_int_distribution<int8_t> distribution_s8(std::numeric_limits<int8_t>::lowest(), std::numeric_limits<int8_t>::max());
|
|
fill(tensor, distribution_s8, seed_offset);
|
|
break;
|
|
}
|
|
case DataType::U16:
|
|
{
|
|
std::uniform_int_distribution<uint16_t> distribution_u16(std::numeric_limits<uint16_t>::lowest(), std::numeric_limits<uint16_t>::max());
|
|
fill(tensor, distribution_u16, seed_offset);
|
|
break;
|
|
}
|
|
case DataType::S16:
|
|
case DataType::QSYMM16:
|
|
{
|
|
std::uniform_int_distribution<int16_t> distribution_s16(std::numeric_limits<int16_t>::lowest(), std::numeric_limits<int16_t>::max());
|
|
fill(tensor, distribution_s16, seed_offset);
|
|
break;
|
|
}
|
|
case DataType::U32:
|
|
{
|
|
std::uniform_int_distribution<uint32_t> distribution_u32(std::numeric_limits<uint32_t>::lowest(), std::numeric_limits<uint32_t>::max());
|
|
fill(tensor, distribution_u32, seed_offset);
|
|
break;
|
|
}
|
|
case DataType::S32:
|
|
{
|
|
std::uniform_int_distribution<int32_t> distribution_s32(std::numeric_limits<int32_t>::lowest(), std::numeric_limits<int32_t>::max());
|
|
fill(tensor, distribution_s32, seed_offset);
|
|
break;
|
|
}
|
|
case DataType::U64:
|
|
{
|
|
std::uniform_int_distribution<uint64_t> distribution_u64(std::numeric_limits<uint64_t>::lowest(), std::numeric_limits<uint64_t>::max());
|
|
fill(tensor, distribution_u64, seed_offset);
|
|
break;
|
|
}
|
|
case DataType::S64:
|
|
{
|
|
std::uniform_int_distribution<int64_t> distribution_s64(std::numeric_limits<int64_t>::lowest(), std::numeric_limits<int64_t>::max());
|
|
fill(tensor, distribution_s64, seed_offset);
|
|
break;
|
|
}
|
|
case DataType::BFLOAT16:
|
|
{
|
|
// It doesn't make sense to check [-inf, inf], so hard code it to a big number
|
|
std::uniform_real_distribution<float> distribution_bf16(-1000.f, 1000.f);
|
|
fill(tensor, distribution_bf16, seed_offset);
|
|
break;
|
|
}
|
|
case DataType::F16:
|
|
{
|
|
// It doesn't make sense to check [-inf, inf], so hard code it to a big number
|
|
std::uniform_real_distribution<float> distribution_f16(-100.f, 100.f);
|
|
fill(tensor, distribution_f16, seed_offset);
|
|
break;
|
|
}
|
|
case DataType::F32:
|
|
{
|
|
// It doesn't make sense to check [-inf, inf], so hard code it to a big number
|
|
std::uniform_real_distribution<float> distribution_f32(-1000.f, 1000.f);
|
|
fill(tensor, distribution_f32, seed_offset);
|
|
break;
|
|
}
|
|
case DataType::F64:
|
|
{
|
|
// It doesn't make sense to check [-inf, inf], so hard code it to a big number
|
|
std::uniform_real_distribution<double> distribution_f64(-1000.f, 1000.f);
|
|
fill(tensor, distribution_f64, seed_offset);
|
|
break;
|
|
}
|
|
case DataType::SIZET:
|
|
{
|
|
std::uniform_int_distribution<size_t> distribution_sizet(std::numeric_limits<size_t>::lowest(), std::numeric_limits<size_t>::max());
|
|
fill(tensor, distribution_sizet, seed_offset);
|
|
break;
|
|
}
|
|
default:
|
|
ARM_COMPUTE_ERROR("NOT SUPPORTED!");
|
|
}
|
|
}
|
|
|
|
template <typename T>
|
|
void AssetsLibrary::fill_tensor_uniform_ranged(T &&tensor,
|
|
std::random_device::result_type seed_offset,
|
|
const std::vector<AssetsLibrary::RangePair> &excluded_range_pairs) const
|
|
{
|
|
using namespace arm_compute::utils::random;
|
|
|
|
switch(tensor.data_type())
|
|
{
|
|
case DataType::U8:
|
|
case DataType::QASYMM8:
|
|
{
|
|
const auto converted_pairs = detail::convert_range_pair<uint8_t>(excluded_range_pairs);
|
|
RangedUniformDistribution<uint8_t> distribution_u8(std::numeric_limits<uint8_t>::lowest(),
|
|
std::numeric_limits<uint8_t>::max(),
|
|
converted_pairs);
|
|
fill(tensor, distribution_u8, seed_offset);
|
|
break;
|
|
}
|
|
case DataType::S8:
|
|
case DataType::QSYMM8:
|
|
{
|
|
const auto converted_pairs = detail::convert_range_pair<int8_t>(excluded_range_pairs);
|
|
RangedUniformDistribution<int8_t> distribution_s8(std::numeric_limits<int8_t>::lowest(),
|
|
std::numeric_limits<int8_t>::max(),
|
|
converted_pairs);
|
|
fill(tensor, distribution_s8, seed_offset);
|
|
break;
|
|
}
|
|
case DataType::U16:
|
|
{
|
|
const auto converted_pairs = detail::convert_range_pair<uint16_t>(excluded_range_pairs);
|
|
RangedUniformDistribution<uint16_t> distribution_u16(std::numeric_limits<uint16_t>::lowest(),
|
|
std::numeric_limits<uint16_t>::max(),
|
|
converted_pairs);
|
|
fill(tensor, distribution_u16, seed_offset);
|
|
break;
|
|
}
|
|
case DataType::S16:
|
|
case DataType::QSYMM16:
|
|
{
|
|
const auto converted_pairs = detail::convert_range_pair<int16_t>(excluded_range_pairs);
|
|
RangedUniformDistribution<int16_t> distribution_s16(std::numeric_limits<int16_t>::lowest(),
|
|
std::numeric_limits<int16_t>::max(),
|
|
converted_pairs);
|
|
fill(tensor, distribution_s16, seed_offset);
|
|
break;
|
|
}
|
|
case DataType::U32:
|
|
{
|
|
const auto converted_pairs = detail::convert_range_pair<uint32_t>(excluded_range_pairs);
|
|
RangedUniformDistribution<uint32_t> distribution_u32(std::numeric_limits<uint32_t>::lowest(),
|
|
std::numeric_limits<uint32_t>::max(),
|
|
converted_pairs);
|
|
fill(tensor, distribution_u32, seed_offset);
|
|
break;
|
|
}
|
|
case DataType::S32:
|
|
{
|
|
const auto converted_pairs = detail::convert_range_pair<int32_t>(excluded_range_pairs);
|
|
RangedUniformDistribution<int32_t> distribution_s32(std::numeric_limits<int32_t>::lowest(),
|
|
std::numeric_limits<int32_t>::max(),
|
|
converted_pairs);
|
|
fill(tensor, distribution_s32, seed_offset);
|
|
break;
|
|
}
|
|
case DataType::BFLOAT16:
|
|
{
|
|
// It doesn't make sense to check [-inf, inf], so hard code it to a big number
|
|
const auto converted_pairs = detail::convert_range_pair<float>(excluded_range_pairs);
|
|
RangedUniformDistribution<float> distribution_bf16(-1000.f, 1000.f, converted_pairs);
|
|
fill(tensor, distribution_bf16, seed_offset);
|
|
break;
|
|
}
|
|
case DataType::F16:
|
|
{
|
|
// It doesn't make sense to check [-inf, inf], so hard code it to a big number
|
|
const auto converted_pairs = detail::convert_range_pair<float>(excluded_range_pairs);
|
|
RangedUniformDistribution<float> distribution_f16(-100.f, 100.f, converted_pairs);
|
|
fill(tensor, distribution_f16, seed_offset);
|
|
break;
|
|
}
|
|
case DataType::F32:
|
|
{
|
|
// It doesn't make sense to check [-inf, inf], so hard code it to a big number
|
|
const auto converted_pairs = detail::convert_range_pair<float>(excluded_range_pairs);
|
|
RangedUniformDistribution<float> distribution_f32(-1000.f, 1000.f, converted_pairs);
|
|
fill(tensor, distribution_f32, seed_offset);
|
|
break;
|
|
}
|
|
default:
|
|
ARM_COMPUTE_ERROR("NOT SUPPORTED!");
|
|
}
|
|
}
|
|
|
|
template <typename T, typename D>
|
|
void AssetsLibrary::fill_tensor_uniform(T &&tensor, std::random_device::result_type seed_offset, D low, D high) const
|
|
{
|
|
switch(tensor.data_type())
|
|
{
|
|
case DataType::U8:
|
|
case DataType::QASYMM8:
|
|
{
|
|
ARM_COMPUTE_ERROR_ON(!(std::is_same<uint8_t, D>::value));
|
|
std::uniform_int_distribution<uint8_t> distribution_u8(low, high);
|
|
fill(tensor, distribution_u8, seed_offset);
|
|
break;
|
|
}
|
|
case DataType::S8:
|
|
case DataType::QSYMM8:
|
|
case DataType::QASYMM8_SIGNED:
|
|
{
|
|
ARM_COMPUTE_ERROR_ON(!(std::is_same<int8_t, D>::value));
|
|
std::uniform_int_distribution<int8_t> distribution_s8(low, high);
|
|
fill(tensor, distribution_s8, seed_offset);
|
|
break;
|
|
}
|
|
case DataType::U16:
|
|
{
|
|
ARM_COMPUTE_ERROR_ON(!(std::is_same<uint16_t, D>::value));
|
|
std::uniform_int_distribution<uint16_t> distribution_u16(low, high);
|
|
fill(tensor, distribution_u16, seed_offset);
|
|
break;
|
|
}
|
|
case DataType::S16:
|
|
case DataType::QSYMM16:
|
|
{
|
|
ARM_COMPUTE_ERROR_ON(!(std::is_same<int16_t, D>::value));
|
|
std::uniform_int_distribution<int16_t> distribution_s16(low, high);
|
|
fill(tensor, distribution_s16, seed_offset);
|
|
break;
|
|
}
|
|
case DataType::U32:
|
|
{
|
|
ARM_COMPUTE_ERROR_ON(!(std::is_same<uint32_t, D>::value));
|
|
std::uniform_int_distribution<uint32_t> distribution_u32(low, high);
|
|
fill(tensor, distribution_u32, seed_offset);
|
|
break;
|
|
}
|
|
case DataType::S32:
|
|
{
|
|
ARM_COMPUTE_ERROR_ON(!(std::is_same<int32_t, D>::value));
|
|
std::uniform_int_distribution<int32_t> distribution_s32(low, high);
|
|
fill(tensor, distribution_s32, seed_offset);
|
|
break;
|
|
}
|
|
case DataType::U64:
|
|
{
|
|
ARM_COMPUTE_ERROR_ON(!(std::is_same<uint64_t, D>::value));
|
|
std::uniform_int_distribution<uint64_t> distribution_u64(low, high);
|
|
fill(tensor, distribution_u64, seed_offset);
|
|
break;
|
|
}
|
|
case DataType::S64:
|
|
{
|
|
ARM_COMPUTE_ERROR_ON(!(std::is_same<int64_t, D>::value));
|
|
std::uniform_int_distribution<int64_t> distribution_s64(low, high);
|
|
fill(tensor, distribution_s64, seed_offset);
|
|
break;
|
|
}
|
|
case DataType::BFLOAT16:
|
|
{
|
|
std::uniform_real_distribution<float> distribution_bf16(low, high);
|
|
fill(tensor, distribution_bf16, seed_offset);
|
|
break;
|
|
}
|
|
case DataType::F16:
|
|
{
|
|
std::uniform_real_distribution<float> distribution_f16(low, high);
|
|
fill(tensor, distribution_f16, seed_offset);
|
|
break;
|
|
}
|
|
case DataType::F32:
|
|
{
|
|
ARM_COMPUTE_ERROR_ON(!(std::is_same<float, D>::value));
|
|
std::uniform_real_distribution<float> distribution_f32(low, high);
|
|
fill(tensor, distribution_f32, seed_offset);
|
|
break;
|
|
}
|
|
case DataType::F64:
|
|
{
|
|
ARM_COMPUTE_ERROR_ON(!(std::is_same<double, D>::value));
|
|
std::uniform_real_distribution<double> distribution_f64(low, high);
|
|
fill(tensor, distribution_f64, seed_offset);
|
|
break;
|
|
}
|
|
case DataType::SIZET:
|
|
{
|
|
ARM_COMPUTE_ERROR_ON(!(std::is_same<size_t, D>::value));
|
|
std::uniform_int_distribution<size_t> distribution_sizet(low, high);
|
|
fill(tensor, distribution_sizet, seed_offset);
|
|
break;
|
|
}
|
|
default:
|
|
ARM_COMPUTE_ERROR("NOT SUPPORTED!");
|
|
}
|
|
}
|
|
|
|
template <typename T>
|
|
void AssetsLibrary::fill_layer_data(T &&tensor, std::string name) const
|
|
{
|
|
#ifdef _WIN32
|
|
const std::string path_separator("\\");
|
|
#else /* _WIN32 */
|
|
const std::string path_separator("/");
|
|
#endif /* _WIN32 */
|
|
const std::string path = _library_path + path_separator + name;
|
|
|
|
// Open file
|
|
std::ifstream stream(path, std::ios::in | std::ios::binary);
|
|
if(!stream.good())
|
|
{
|
|
throw framework::FileNotFound("Could not load npy file: " + path);
|
|
}
|
|
|
|
validate_npy_header(stream, tensor.data_type(), tensor.shape());
|
|
|
|
// Read data
|
|
if(tensor.padding().empty())
|
|
{
|
|
// If tensor has no padding read directly from stream.
|
|
stream.read(reinterpret_cast<char *>(tensor.data()), tensor.size());
|
|
}
|
|
else
|
|
{
|
|
// If tensor has padding accessing tensor elements through execution window.
|
|
Window window;
|
|
window.use_tensor_dimensions(tensor.shape());
|
|
|
|
execute_window_loop(window, [&](const Coordinates & id)
|
|
{
|
|
stream.read(reinterpret_cast<char *>(tensor(id)), tensor.element_size());
|
|
});
|
|
}
|
|
}
|
|
|
|
template <typename T, typename D>
|
|
void AssetsLibrary::fill_tensor_value(T &&tensor, D value) const
|
|
{
|
|
fill_tensor_uniform(tensor, 0, value, value);
|
|
}
|
|
} // namespace test
|
|
} // namespace arm_compute
|
|
#endif /* ARM_COMPUTE_TEST_TENSOR_LIBRARY_H */
|