test_tools.hpp 8.96 KB
Newer Older
1
//*****************************************************************************
2
// Copyright 2017-2019 Intel Corporation
3 4 5 6 7 8 9 10 11 12 13 14 15
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//*****************************************************************************
16

17
#pragma once
18

19
#include <exception>
20
#include <fstream>
21 22
#include <iomanip>
#include <iostream>
23
#include <list>
Robert Kimball's avatar
Robert Kimball committed
24
#include <memory>
25
#include <random>
26
#include <vector>
27

Scott Cyphers's avatar
Scott Cyphers committed
28
#include "ngraph/descriptor/layout/tensor_layout.hpp"
29
#include "ngraph/file_util.hpp"
30
#include "ngraph/log.hpp"
31
#include "ngraph/runtime/backend.hpp"
32
#include "ngraph/runtime/tensor.hpp"
33
#include "ngraph/serializer.hpp"
34

35
namespace ngraph
36
{
37
    class Node;
38
    class Function;
39
}
40

41
bool validate_list(const std::list<std::shared_ptr<ngraph::Node>>& nodes);
42
std::shared_ptr<ngraph::Function> make_test_graph();
43
#ifndef NGRAPH_JSON_DISABLE
44
std::shared_ptr<ngraph::Function> make_function_from_file(const std::string& file_name);
45
#endif
46 47

template <typename T>
48
void copy_data(std::shared_ptr<ngraph::runtime::Tensor> tv, const std::vector<T>& data)
49 50
{
    size_t data_size = data.size() * sizeof(T);
51
    tv->write(data.data(), data_size);
52
}
53 54

template <typename T>
55
std::vector<T> read_vector(std::shared_ptr<ngraph::runtime::Tensor> tv)
56
{
57
    if (ngraph::element::from<T>() != tv->get_element_type())
58
    {
59
        throw std::invalid_argument("read_vector type must match Tensor type");
60 61 62 63
    }
    size_t element_count = ngraph::shape_size(tv->get_shape());
    size_t size = element_count * sizeof(T);
    std::vector<T> rc(element_count);
64
    tv->read(rc.data(), size);
65 66 67
    return rc;
}

68
std::vector<float> read_float_vector(std::shared_ptr<ngraph::runtime::Tensor> tv);
69

70
template <typename T>
71
void write_vector(std::shared_ptr<ngraph::runtime::Tensor> tv, const std::vector<T>& values)
72
{
73
    tv->write(values.data(), values.size() * sizeof(T));
74
}
75

76 77 78 79 80 81 82 83 84 85 86 87 88 89 90
template <typename T>
std::vector<std::shared_ptr<T>> get_ops_of_type(std::shared_ptr<ngraph::Function> f)
{
    std::vector<std::shared_ptr<T>> ops;
    for (auto op : f->get_ops())
    {
        if (auto cop = std::dynamic_pointer_cast<T>(op))
        {
            ops.push_back(cop);
        }
    }

    return ops;
}

91 92 93 94 95 96 97 98 99 100 101 102 103 104
template <typename T>
size_t count_ops_of_type(std::shared_ptr<ngraph::Function> f)
{
    size_t count = 0;
    for (auto op : f->get_ops())
    {
        if (std::dynamic_pointer_cast<T>(op))
        {
            count++;
        }
    }

    return count;
}
105

106 107 108 109 110 111 112 113 114 115
template <typename T>
void init_int_tv(ngraph::runtime::Tensor* tv, std::default_random_engine& engine, T min, T max)
{
    size_t size = tv->get_element_count();
    std::uniform_int_distribution<T> dist(min, max);
    std::vector<T> vec(size);
    for (T& element : vec)
    {
        element = dist(engine);
    }
116
    tv->write(vec.data(), vec.size() * sizeof(T));
117 118 119 120 121 122 123 124 125 126 127 128
}

template <typename T>
void init_real_tv(ngraph::runtime::Tensor* tv, std::default_random_engine& engine, T min, T max)
{
    size_t size = tv->get_element_count();
    std::uniform_real_distribution<T> dist(min, max);
    std::vector<T> vec(size);
    for (T& element : vec)
    {
        element = dist(engine);
    }
129
    tv->write(vec.data(), vec.size() * sizeof(T));
130 131 132 133
}

void random_init(ngraph::runtime::Tensor* tv, std::default_random_engine& engine);

134
template <typename T1, typename T2>
tsocha's avatar
tsocha committed
135 136
std::vector<std::shared_ptr<ngraph::runtime::Tensor>>
    prepare_and_run(const std::shared_ptr<ngraph::Function>& function,
137 138
                    std::vector<std::vector<T1>> t1args,
                    std::vector<std::vector<T2>> t2args,
tsocha's avatar
tsocha committed
139
                    const std::string& backend_id)
140
{
141
    auto backend = ngraph::runtime::Backend::create(backend_id);
142

143
    auto parms = function->get_parameters();
144

145
    if (parms.size() != t1args.size() + t2args.size())
146 147 148 149
    {
        throw ngraph::ngraph_error("number of parameters and arguments don't match");
    }

150 151 152 153 154
    std::vector<std::shared_ptr<ngraph::runtime::Tensor>> arg_tensors(t1args.size() +
                                                                      t2args.size());

    size_t total_arg_count = 0;
    for (size_t i = 0; i < t1args.size(); i++)
155
    {
156 157 158 159 160 161 162 163 164 165 166 167 168 169 170
        auto t = backend->create_tensor(parms.at(total_arg_count)->get_element_type(),
                                        parms.at(total_arg_count)->get_shape());
        auto x = t1args.at(i);
        copy_data(t, x);
        arg_tensors.at(total_arg_count) = t;
        total_arg_count++;
    }

    for (size_t i = 0; i < t2args.size(); i++)
    {
        auto t = backend->create_tensor(parms.at(total_arg_count)->get_element_type(),
                                        parms.at(total_arg_count)->get_shape());
        copy_data(t, t2args.at(i));
        arg_tensors.at(total_arg_count) = t;
        total_arg_count++;
171 172
    }

173
    auto results = function->get_results();
174
    std::vector<std::shared_ptr<ngraph::runtime::Tensor>> result_tensors(results.size());
175 176 177 178 179 180 181

    for (size_t i = 0; i < results.size(); i++)
    {
        result_tensors.at(i) =
            backend->create_tensor(results.at(i)->get_element_type(), results.at(i)->get_shape());
    }

182
    auto handle = backend->compile(function);
183
    handle->call_with_validate(result_tensors, arg_tensors);
184

tsocha's avatar
tsocha committed
185 186 187
    return result_tensors;
}

188 189 190 191 192 193 194 195 196 197 198 199 200 201 202
template <typename T>
std::vector<std::shared_ptr<ngraph::runtime::Tensor>>
    prepare_and_run(const std::shared_ptr<ngraph::Function>& function,
                    std::vector<std::vector<T>> args,
                    const std::string& backend_id)
{
    std::vector<std::vector<T>> emptyargs;
    return prepare_and_run<T, T>(function, args, emptyargs, backend_id);
}

template <typename TIN1, typename TIN2, typename TOUT>
std::vector<std::vector<TOUT>> execute(const std::shared_ptr<ngraph::Function>& function,
                                       std::vector<std::vector<TIN1>> t1args,
                                       std::vector<std::vector<TIN2>> t2args,
                                       const std::string& backend_id)
tsocha's avatar
tsocha committed
203 204
{
    std::vector<std::shared_ptr<ngraph::runtime::Tensor>> result_tensors =
205
        prepare_and_run(function, t1args, t2args, backend_id);
206

207
    std::vector<std::vector<TOUT>> result_vectors;
208 209
    for (auto rt : result_tensors)
    {
210
        result_vectors.push_back(read_vector<TOUT>(rt));
211 212 213
    }
    return result_vectors;
}
214

215 216 217 218 219 220 221 222 223
template <typename TIN, typename TOUT = TIN>
std::vector<std::vector<TOUT>> execute(const std::shared_ptr<ngraph::Function>& function,
                                       std::vector<std::vector<TIN>> args,
                                       const std::string& backend_id)
{
    std::vector<std::vector<TIN>> emptyargs;
    return execute<TIN, TIN, TOUT>(function, args, emptyargs, backend_id);
}

224
template <typename T>
225 226 227
std::string get_results_str(const std::vector<T>& ref_data,
                            const std::vector<T>& actual_data,
                            size_t max_results = 16)
228
{
229
    std::stringstream ss;
230
    size_t num_results = std::min(static_cast<size_t>(max_results), ref_data.size());
231
    ss << "First " << num_results << " results";
232 233
    for (size_t i = 0; i < num_results; ++i)
    {
234 235 236 237
        ss << std::endl
           // use unary + operator to force integral values to be displayed as numbers
           << std::setw(4) << i << " ref: " << std::setw(16) << std::left << +ref_data[i]
           << "  actual: " << std::setw(16) << std::left << +actual_data[i];
238
    }
239
    ss << std::endl;
240 241

    return ss.str();
242 243 244
}

template <>
245 246
std::string get_results_str(const std::vector<char>& ref_data,
                            const std::vector<char>& actual_data,
247
                            size_t max_results);
248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279

/// \brief      Reads a binary file to a vector.
///
/// \param[in]  path  The path where the file is located.
///
/// \tparam     T     The type we want to interpret as the elements in binary file.
///
/// \return     Return vector of data read from input binary file.
///
template <typename T>
std::vector<T> read_binary_file(const std::string& path)
{
    std::vector<T> file_content;
    std::ifstream inputs_fs{path, std::ios::in | std::ios::binary};
    if (!inputs_fs)
    {
        throw std::runtime_error("Failed to open the file: " + path);
    }

    inputs_fs.seekg(0, std::ios::end);
    auto size = inputs_fs.tellg();
    inputs_fs.seekg(0, std::ios::beg);
    if (size % sizeof(T) != 0)
    {
        throw std::runtime_error(
            "Error reading binary file content: Input file size (in bytes) "
            "is not a multiple of requested data type size.");
    }
    file_content.resize(size / sizeof(T));
    inputs_fs.read(reinterpret_cast<char*>(file_content.data()), size);
    return file_content;
}