Skip to content

GitLab

Commit 4487d4c9 authored by Umang Yadav's avatar Umang Yadav
Browse files

fix the argument order, add atol,rtols etc.

parent 31b55797
Expand all Hide whitespace changes
Inline Side-by-side
Showing with 490 additions and 457 deletions
src/driver/verify.cpp
View file @ 4487d4c9
......@@ -22,6 +22,7 @@
* THE SOFTWARE.
*/
#include "verify.hpp"
#include "migraphx/verify.hpp"
#include "perf.hpp"
#include <migraphx/register_target.hpp>
......@@ -84,7 +85,7 @@ void verify_program(const std::string& name,
std::size_t output_num = x.size();
for(std::size_t i = 0; i < output_num; ++i)
{
verify_args_with_threshold(name, x[i], y[i], threshold);
verify_args_with_threshold(name, x[i], y[i], verify::threshold{threshold});
}
}
......
src/include/migraphx/verify.hpp
View file @ 4487d4c9
......@@ -189,7 +189,7 @@ double rms_range(const R1& r1, const R2& r2)
}
template <class R>
double get_threshold(const R&, std::size_t tolerance = 80)
double get_rms_tol(const R&, std::size_t tolerance = 80)
{
double threshold = std::numeric_limits<range_value<R>>::epsilon() * tolerance;
return threshold;
......@@ -214,13 +214,39 @@ struct expected
template <class T>
expected(const T&) -> expected<T>;
struct threshold
{
double rms_tol = 0.001;
double atol = 0.001;
double rtol = 0.001;
};
template <class R1, class R2>
bool allclose(const R1& r1, const R2& r2, threshold thres)
{
std::size_t n = range_distance(r1);
if(n == range_distance(r2))
{
auto idx = mismatch_idx(r1, r2, [&](auto x, auto y) {
return abs_diff(double(x), double(y)) > thres.atol + thres.rtol * std::abs(double(y));
});
if(idx < range_distance(r1))
{
return false;
}
return true;
}
else
return false;
}
template <class R1, class R2>
bool verify_range(const R1& r1,
const R2& r2,
std::size_t tolerance = 80,
double* out_error = nullptr)
{
double threshold = get_threshold(r1, tolerance);
double threshold = get_rms_tol(r1, tolerance);
auto error = rms_range(r1, r2);
if(out_error != nullptr)
*out_error = error;
......@@ -230,13 +256,14 @@ bool verify_range(const R1& r1,
template <class R1, class R2>
bool verify_range_with_threshold(const R1& r1,
const expected<R2>& r2,
double threshold,
threshold tols = threshold{},
double* out_error = nullptr)
{
auto error = rms_range(r1, r2.data());
auto rms_error = rms_range(r1, r2.data());
// auto ewise_verify = allclose(r1, r2.data(), tols);
if(out_error != nullptr)
*out_error = error;
return error <= threshold;
*out_error = rms_error;
return rms_error <= tols.rms_tol;
}
// expected argument should be passed as second, but if it is passed as the first by mistake then
......@@ -244,10 +271,10 @@ bool verify_range_with_threshold(const R1& r1,
template <class R1, class R2>
bool verify_range_with_threshold(const expected<R1>& r1,
const R2& r2,
double threshold,
threshold tols = threshold{},
double* out_error = nullptr)
{
return verify_range(r2, r1, threshold, out_error);
return verify_range(r2, r1, tols, out_error);
}
} // namespace verify
......
src/include/migraphx/verify_args.hpp
View file @ 4487d4c9
......@@ -34,11 +34,11 @@ inline namespace MIGRAPHX_INLINE_NS {
MIGRAPHX_EXPORT bool verify_args_with_threshold(const std::string& name,
const argument& ref_arg,
const argument& target_arg,
double threshold);
verify::threshold);
MIGRAPHX_EXPORT bool verify_args(const std::string& name,
const argument& ref_arg,
const argument& target_arg,
const argument& ref_arg,
std::size_t tolerance = 80);
} // namespace MIGRAPHX_INLINE_NS
......
src/verify_args.cpp
View file @ 4487d4c9
......@@ -30,13 +30,12 @@ inline namespace MIGRAPHX_INLINE_NS {
bool verify_args_with_threshold(const std::string& name,
const argument& target_arg,
const argument& ref_arg,
double threshold)
verify::threshold tols)
{
bool passed = true;
visit_all(ref_arg, target_arg)([&](auto ref, auto target) {
double error;
passed =
verify::verify_range_with_threshold(target, verify::expected{ref}, threshold, &error);
passed = verify::verify_range_with_threshold(target, verify::expected{ref}, tols, &error);
if(not passed)
{
// TODO: Check for nans
......@@ -95,13 +94,14 @@ bool verify_args_with_threshold(const std::string& name,
}
bool verify_args(const std::string& name,
const argument& ref_arg,
const argument& target_arg,
const argument& ref_arg,
std::size_t tolerance)
{
double threshold = 0.001;
target_arg.visit([&](auto ta) { threshold = verify::get_threshold(ta, tolerance); });
return verify_args_with_threshold(name, target_arg, ref_arg, threshold);
double rms_tol = 0.001;
target_arg.visit([&](auto ta) { rms_tol = verify::get_rms_tol(ta, tolerance); });
verify::threshold tols{rms_tol};
return verify_args_with_threshold(name, target_arg, ref_arg, tols);
}
} // namespace MIGRAPHX_INLINE_NS
......
test/gpu/codegen_literal.cpp
View file @ 4487d4c9
......@@ -80,7 +80,7 @@ TEST_CASE(mul_literal_round_test)
migraphx::target gpu_t = migraphx::make_target("gpu");
run_prog(p, gpu_t, m, gpu_result);
EXPECT(migraphx::verify::verify_range(ref_result, gpu_result));
EXPECT(migraphx::verify::verify_range(gpu_result, ref_result));
}
int main(int argc, const char* argv[]) { test::run(argc, argv); }
test/gpu/manage_host_buffer.cpp
View file @ 4487d4c9
......@@ -53,7 +53,6 @@ TEST_CASE(host_same_buffer_copy)
migraphx::parameter_map pp;
std::vector<float> a_vec(ss.elements(), -1);
std::vector<float> b_vec(ss.elements(), 2);
std::vector<float> c_vec(ss.elements(), 0);
pp["a"] = migraphx::argument(ss, a_vec.data());
pp["b"] = migraphx::argument(ss, b_vec.data());
std::vector<float> gpu_result;
......@@ -64,7 +63,8 @@ TEST_CASE(host_same_buffer_copy)
auto result = p.eval(pp).back();
std::vector<float> results_vector(ss.elements(), -1);
result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
EXPECT(migraphx::verify::verify_range(c_vec, results_vector));
std::vector<float> gold_vec(ss.elements(), 0);
EXPECT(migraphx::verify::verify_range(results_vector, gold_vec));
}
TEST_CASE(arguments_lifetime)
......
test/gpu/mlir.cpp
View file @ 4487d4c9
......@@ -133,7 +133,7 @@ bool verify_mlir(const migraphx::module& mmlir)
auto inputs = generate_params(ref);
auto mlir = create_program_from_mlir(mmlir);
return migraphx::verify_args("mlir", run_ref(ref, inputs), run_gpu(mlir, inputs));
return migraphx::verify_args("mlir", run_gpu(mlir, inputs), run_ref(ref, inputs));
}
TEST_CASE(conv)
......
test/gpu/quantization.cpp
View file @ 4487d4c9
......@@ -40,7 +40,6 @@
TEST_CASE(gpu_target_copy)
{
migraphx::target gpu_t = migraphx::make_target("gpu");
migraphx::target ref_t = migraphx::make_target("ref");
migraphx::shape s{migraphx::shape::int8_type, {2, 3, 4, 5}};
auto ref_arg_orig = migraphx::generate_argument(s, 0x123456L);
......@@ -118,9 +117,12 @@ TEST_CASE(int8_quantization)
// the regular pipeline uses the rewrite_quantization in the much
// earlier stage.
if(migraphx::gpu::mlir_enabled())
EXPECT(migraphx::verify::verify_range_with_threshold(gpu_result, migraphx::verify::expected{ref_result}, 0.01));
EXPECT(migraphx::verify::verify_range_with_threshold(
gpu_result,
migraphx::verify::expected{ref_result},
migraphx::verify::threshold{0.01}));
else
EXPECT(migraphx::verify::verify_range(ref_result, gpu_result));
EXPECT(migraphx::verify::verify_range(gpu_result, ref_result));
}
}
......
test/onnx/verify_onnx.cpp
View file @ 4487d4c9
......@@ -76,15 +76,15 @@ TEST_CASE(batch_norm_flat_test)
migraphx::shape x_shape{migraphx::shape::float_type, {10}};
migraphx::shape c_shape(migraphx::shape::float_type, {1});
std::vector<float> x_data = {1.6524342,
-0.51048076,
0.32543048,
2.4410043,
2.0833702,
0.44981122,
1.0044622,
-0.24006313,
-0.43065986,
0.07626268};
-0.51048076,
0.32543048,
2.4410043,
2.0833702,
0.44981122,
1.0044622,
-0.24006313,
-0.43065986,
0.07626268};
std::vector<float> scale_data = {-0.02927135};
std::vector<float> bias_data = {0.42347777};
std::vector<float> mean_data = {-0.00449735};
......@@ -309,12 +309,12 @@ TEST_CASE(celu_verify_test)
std::vector<float> result_vector;
result.visit([&](auto output) { result_vector.assign(output.begin(), output.end()); });
std::vector<float> correct(6);
std::vector<float> gold(6);
float alpha = 0.5;
std::transform(data.begin(), data.end(), correct.begin(), [&](auto x) {
std::transform(data.begin(), data.end(), gold.begin(), [&](auto x) {
return std::max(0.0f, x) + std::min(0.0f, alpha * std::expm1(x / alpha));
});
EXPECT(migraphx::verify::verify_range(result_vector, correct));
EXPECT(migraphx::verify::verify_range(result_vector, gold));
}
TEST_CASE(clip_args_type_mismatch)
......@@ -374,11 +374,11 @@ TEST_CASE(spacetodepth_depthtospace_test)
// space to depth
auto p1 = migraphx::parse_onnx("spacetodepth_simple_test.onnx");
p1.compile(migraphx::make_target("ref"));
std::vector<float> data_in(48);
std::iota(std::begin(data_in), std::end(data_in), 0);
std::vector<float> gold_data_in(48);
std::iota(std::begin(gold_data_in), std::end(gold_data_in), 0);
migraphx::shape s_x_1{migraphx::shape::float_type, {1, 2, 4, 6}};
migraphx::parameter_map pp1;
pp1["x"] = migraphx::argument(s_x_1, data_in.data());
pp1["x"] = migraphx::argument(s_x_1, gold_data_in.data());
auto result1 = p1.eval(pp1).back();
// depth to space
auto p2 = migraphx::parse_onnx("depthtospace_simple_test.onnx");
......@@ -388,7 +388,7 @@ TEST_CASE(spacetodepth_depthtospace_test)
auto result2 = p2.eval(pp2).back();
std::vector<float> result_vector2;
result2.visit([&](auto output) { result_vector2.assign(output.begin(), output.end()); });
EXPECT(migraphx::verify::verify_range(result_vector2, data_in));
EXPECT(migraphx::verify::verify_range(result_vector2, gold_data_in));
}
TEST_CASE(eyelike_verify_test)
......@@ -405,8 +405,8 @@ TEST_CASE(eyelike_verify_test)
std::vector<float> result_vector;
result.visit([&](auto output) { result_vector.assign(output.begin(), output.end()); });
std::vector<float> eyelike_mat = {0., 1., 0., 0., 0., 0., 1., 0., 0., 0., 0., 1.};
EXPECT(migraphx::verify::verify_range(result_vector, eyelike_mat));
std::vector<float> gold_eyelike_mat = {0., 1., 0., 0., 0., 0., 1., 0., 0., 0., 0., 1.};
EXPECT(migraphx::verify::verify_range(result_vector, gold_eyelike_mat));
}
TEST_CASE(eyelike_verify_negk_test)
......@@ -423,8 +423,8 @@ TEST_CASE(eyelike_verify_negk_test)
std::vector<float> result_vector;
result.visit([&](auto output) { result_vector.assign(output.begin(), output.end()); });
std::vector<float> eyelike_mat = {0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0.};
EXPECT(migraphx::verify::verify_range(result_vector, eyelike_mat));
std::vector<float> gold_eyelike_mat = {0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0.};
EXPECT(migraphx::verify::verify_range(result_vector, gold_eyelike_mat));
}
TEST_CASE(gather_elements)
......@@ -1012,19 +1012,19 @@ TEST_CASE(lpnormalization_2norm)
std::vector<float> result_vector;
result.visit([&](auto output) { result_vector.assign(output.begin(), output.end()); });
std::vector<float> correct{0.f,
2.f / 3.f,
-2.f / 3.f,
1.f / 3.f,
1.f / 6.f,
-5.f / 6.f,
3.f / 6.f,
-1.f / 6.f,
-4.f / 5.f,
3.f / 5.f,
0.f,
0.f};
EXPECT(migraphx::verify::verify_range(result_vector, correct));
std::vector<float> gold{0.f,
2.f / 3.f,
-2.f / 3.f,
1.f / 3.f,
1.f / 6.f,
-5.f / 6.f,
3.f / 6.f,
-1.f / 6.f,
-4.f / 5.f,
3.f / 5.f,
0.f,
0.f};
EXPECT(migraphx::verify::verify_range(result_vector, gold));
}
TEST_CASE(mean_broadcast_test)
......
test/quantization.cpp
View file @ 4487d4c9
......@@ -1078,7 +1078,9 @@ TEST_CASE(int8_quantization_dot)
run_prog(p, ref_t, m, no_quant_result);
EXPECT(migraphx::verify::verify_range_with_threshold(
quant_result, migraphx::verify::expected{no_quant_result}, 0.003));
quant_result,
migraphx::verify::expected{no_quant_result},
migraphx::verify::threshold{0.003}));
}
}
......
test/ref/broadcast.cpp
View file @ 4487d4c9
......@@ -114,6 +114,6 @@ TEST_CASE(isnan_broadcast_test)
auto result = p.eval({}).back();
std::vector<float> results_vector;
result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
std::vector<float> correct = {0, 0, 0, 0, 1, 1};
EXPECT(migraphx::verify::verify_range(results_vector, correct));
std::vector<float> gold = {0, 0, 0, 0, 1, 1};
EXPECT(migraphx::verify::verify_range(results_vector, gold));
}
test/ref/convolution.cpp
View file @ 4487d4c9
This diff is collapsed.
test/ref/dot_op.cpp
View file @ 4487d4c9
......@@ -56,18 +56,7 @@ void dot_2d_test()
1.53027987e+00,
-3.81407415e-04,
-3.29650255e-01};
std::vector<float> c = {-1.56327541e+00,
-7.09570140e-01,
-5.37424982e-01,
-2.22994831e-01,
-2.15586437e+00,
2.09177941e-03,
-1.47279677e+00,
2.02627040e-01,
-6.04527691e-01,
-1.29885596e+00,
2.16294914e+00,
-1.48101497e-01};
migraphx::shape a_shape{migraphx::shape::get_type<T>{}, {4, 5}};
auto al = mm->add_literal(migraphx::literal{a_shape, a});
migraphx::shape b_shape{migraphx::shape::get_type<T>{}, {5, 3}};
......@@ -77,7 +66,19 @@ void dot_2d_test()
auto result = p.eval({}).back();
std::vector<T> results_vector;
result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
EXPECT(migraphx::verify::verify_range(c, results_vector));
std::vector<float> gold = {-1.56327541e+00,
-7.09570140e-01,
-5.37424982e-01,
-2.22994831e-01,
-2.15586437e+00,
2.09177941e-03,
-1.47279677e+00,
2.02627040e-01,
-6.04527691e-01,
-1.29885596e+00,
2.16294914e+00,
-1.48101497e-01};
EXPECT(migraphx::verify::verify_range(results_vector, gold));
}
TEST_CASE_REGISTER(dot_2d_test<float>)
TEST_CASE_REGISTER(dot_2d_test<double>)
......@@ -87,38 +88,38 @@ void dot_4d_test()
{
migraphx::program p;
auto* mm = p.get_main_module();
std::vector<T> a = {-0.00925222, 0.56250403, 0.70107397, 0.75402161, -0.505885,
1.33628943, -0.11413, -0.31270559, 1.59336732, -0.19361027,
-0.91620867, 0.40108416, -0.06969921, 0.68483471, -0.39906632,
-1.66423624, 0.69040076, -1.31490171, -0.11282616, -0.79391814};
std::vector<float> b = {6.09568541e-01,
-6.10527007e-01,
3.66646462e-01,
1.18951101e-01,
5.58777432e-01,
-3.21296298e-01,
-5.95997198e-01,
-5.01425721e-01,
-2.84606807e-01,
-5.73673557e-01,
-8.99430260e-01,
-4.25103093e-01,
1.53027987e+00,
-3.81407415e-04,
-3.29650255e-01};
std::vector<float> c = {-1.56327541e+00,
-7.09570140e-01,
-5.37424982e-01,
-2.22994831e-01,
-2.15586437e+00,
2.09177941e-03,
-1.47279677e+00,
2.02627040e-01,
-6.04527691e-01,
-1.29885596e+00,
2.16294914e+00,
-1.48101497e-01};
auto* mm = p.get_main_module();
std::vector<T> a = {-0.00925222, 0.56250403, 0.70107397, 0.75402161, -0.505885,
1.33628943, -0.11413, -0.31270559, 1.59336732, -0.19361027,
-0.91620867, 0.40108416, -0.06969921, 0.68483471, -0.39906632,
-1.66423624, 0.69040076, -1.31490171, -0.11282616, -0.79391814};
std::vector<float> b = {6.09568541e-01,
-6.10527007e-01,
3.66646462e-01,
1.18951101e-01,
5.58777432e-01,
-3.21296298e-01,
-5.95997198e-01,
-5.01425721e-01,
-2.84606807e-01,
-5.73673557e-01,
-8.99430260e-01,
-4.25103093e-01,
1.53027987e+00,
-3.81407415e-04,
-3.29650255e-01};
std::vector<float> gold = {-1.56327541e+00,
-7.09570140e-01,
-5.37424982e-01,
-2.22994831e-01,
-2.15586437e+00,
2.09177941e-03,
-1.47279677e+00,
2.02627040e-01,
-6.04527691e-01,
-1.29885596e+00,
2.16294914e+00,
-1.48101497e-01};
migraphx::shape a_shape{migraphx::shape::get_type<T>{}, {1, 1, 4, 5}};
auto al = mm->add_literal(migraphx::literal{a_shape, a});
migraphx::shape b_shape{migraphx::shape::get_type<T>{}, {1, 1, 5, 3}};
......@@ -128,7 +129,7 @@ void dot_4d_test()
auto result = p.eval({}).back();
std::vector<T> results_vector;
result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
EXPECT(migraphx::verify::verify_range(c, results_vector));
EXPECT(migraphx::verify::verify_range(results_vector, gold));
}
TEST_CASE_REGISTER(dot_4d_test<float>)
TEST_CASE_REGISTER(dot_4d_test<double>)
......@@ -166,7 +167,7 @@ TEST_CASE(dot_3D_test)
std::vector<float> m;
result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
std::vector<float> m_res = {0.18208394,
std::vector<float> gold = {0.18208394,
-0.49276402,
0.87189133,
0.75150114,
......@@ -183,7 +184,7 @@ TEST_CASE(dot_3D_test)
0.40245487,
1.80182751};
EXPECT(migraphx::verify::verify_range(m, m_res));
EXPECT(migraphx::verify::verify_range(m, gold));
}
TEST_CASE(dot_3D_C_test0)
......@@ -242,7 +243,7 @@ TEST_CASE(dot_3D_C_test0)
std::vector<float> m;
result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
std::vector<float> m_res = {0.18208394,
std::vector<float> gold = {0.18208394,
-0.49276402,
0.87189133,
0.75150114,
......@@ -259,7 +260,7 @@ TEST_CASE(dot_3D_C_test0)
0.40245487,
1.80182751};
EXPECT(migraphx::verify::verify_range(m, m_res));
EXPECT(migraphx::verify::verify_range(m, gold));
}
TEST_CASE(dot_3D_C_test1)
......@@ -309,7 +310,7 @@ TEST_CASE(dot_3D_C_test1)
std::vector<float> m;
result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
std::vector<float> m_res = {0.18208394,
std::vector<float> gold = {0.18208394,
-0.49276402,
0.87189133,
0.75150114,
......@@ -318,7 +319,7 @@ TEST_CASE(dot_3D_C_test1)
-0.95536130,
2.27996211};
EXPECT(migraphx::verify::verify_range(m, m_res));
EXPECT(migraphx::verify::verify_range(m, gold));
}
TEST_CASE(dot_4D_test1)
......@@ -351,13 +352,13 @@ TEST_CASE(dot_4D_test1)
std::vector<float> m;
result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
std::vector<float> m_res = {0.26735861, -4.30770895, 1.05257728, -1.19954265, 0.50493170,
std::vector<float> gold = {0.26735861, -4.30770895, 1.05257728, -1.19954265, 0.50493170,
-0.18729756, 1.09137941, -1.09298312, 3.42956915, -0.41681939,
0.17833257, 0.26040336, 0.15351280, 1.87632715, -0.63545406,
-0.95467340, -1.74728628, -2.42477030, 0.76262372, 0.15539164,
3.32281958, 0.96769613, 0.43727545, 2.43019906};
EXPECT(migraphx::verify::verify_range(m, m_res));
EXPECT(migraphx::verify::verify_range(m, gold));
}
TEST_CASE(dot_4D_alpha_beta_test)
......@@ -405,13 +406,13 @@ TEST_CASE(dot_4D_alpha_beta_test)
std::vector<float> m;
result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
std::vector<float> m_res = {-0.91147203, 0.47540785, -0.30313587, 0.43325099, -0.43711586,
std::vector<float> gold = {-0.91147203, 0.47540785, -0.30313587, 0.43325099, -0.43711586,
0.50928632, 0.06919868, -0.80382802, -0.05125718, -0.06685650,
-0.06972163, 0.32407764, 0.45677396, 0.25909489, 0.56911252,
-0.17183724, 0.10858734, 0.39406289, 0.04662959, 1.07979824,
0.40355016, 0.52410648, -0.31728447, 1.09550845};
EXPECT(migraphx::verify::verify_range(m, m_res));
EXPECT(migraphx::verify::verify_range(m, gold));
}
TEST_CASE(dot_4D_alpha_beta_C_test)
......@@ -457,13 +458,13 @@ TEST_CASE(dot_4D_alpha_beta_C_test)
std::vector<float> m;
result.visit([&](auto output) { m.assign(output.begin(), output.end()); });
std::vector<float> m_res = {-0.91147203, 0.47540785, -0.30313587, 0.43325099, -0.43711586,
std::vector<float> gold = {-0.91147203, 0.47540785, -0.30313587, 0.43325099, -0.43711586,
0.50928632, 0.06919868, -0.80382802, -0.05125718, -0.06685650,
-0.06972163, 0.32407764, 0.45677396, 0.25909489, 0.56911252,
-0.17183724, 0.10858734, 0.39406289, 0.04662959, 1.07979824,
0.40355016, 0.52410648, -0.31728447, 1.09550845};
EXPECT(migraphx::verify::verify_range(m, m_res));
EXPECT(migraphx::verify::verify_range(m, gold));
}
TEST_CASE(dot_2D_C_test0)
......@@ -1202,19 +1203,19 @@ TEST_CASE(dot_dyn_2D_test)
auto result = p.eval(params).back();
std::vector<float> results_vector;
result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
std::vector<float> c = {-1.56327541e+00,
-7.09570140e-01,
-5.37424982e-01,
-2.22994831e-01,
-2.15586437e+00,
2.09177941e-03,
-1.47279677e+00,
2.02627040e-01,
-6.04527691e-01,
-1.29885596e+00,
2.16294914e+00,
-1.48101497e-01};
EXPECT(migraphx::verify::verify_range(c, results_vector));
std::vector<float> gold = {-1.56327541e+00,
-7.09570140e-01,
-5.37424982e-01,
-2.22994831e-01,
-2.15586437e+00,
2.09177941e-03,
-1.47279677e+00,
2.02627040e-01,
-6.04527691e-01,
-1.29885596e+00,
2.16294914e+00,
-1.48101497e-01};
EXPECT(migraphx::verify::verify_range(results_vector, gold));
}
TEST_CASE(dot_dyn_4D_test)
......@@ -1256,19 +1257,19 @@ TEST_CASE(dot_dyn_4D_test)
auto result = p.eval(params).back();
std::vector<float> results_vector;
result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
std::vector<float> c = {-1.56327541e+00,
-7.09570140e-01,
-5.37424982e-01,
-2.22994831e-01,
-2.15586437e+00,
2.09177941e-03,
-1.47279677e+00,
2.02627040e-01,
-6.04527691e-01,
-1.29885596e+00,
2.16294914e+00,
-1.48101497e-01};
EXPECT(migraphx::verify::verify_range(c, results_vector));
std::vector<float> gold = {-1.56327541e+00,
-7.09570140e-01,
-5.37424982e-01,
-2.22994831e-01,
-2.15586437e+00,
2.09177941e-03,
-1.47279677e+00,
2.02627040e-01,
-6.04527691e-01,
-1.29885596e+00,
2.16294914e+00,
-1.48101497e-01};
EXPECT(migraphx::verify::verify_range(results_vector, gold));
}
TEST_CASE(quant_dot_2args_multi4_1)
......
test/ref/im2col.cpp
View file @ 4487d4c9
......@@ -40,14 +40,14 @@ TEST_CASE(im2col_3x3_no_pad_identity_test)
std::size_t channels = 1;
std::vector<int32_t> weights(channels * f[0] * f[1]);
std::vector<int32_t> input(channels * size[0] * size[1]);
std::iota(input.begin(), input.end(), 0);
std::vector<int32_t> gold(channels * size[0] * size[1]);
std::iota(gold.begin(), gold.end(), 0);
migraphx::program p;
auto* mm = p.get_main_module();
migraphx::shape s_image{migraphx::shape::int32_type, {1, channels, size[0], size[1]}};
migraphx::shape s_weights{migraphx::shape::int32_type, {1, channels, f[0], f[1]}};
auto l_image = mm->add_literal(migraphx::literal{s_image, input});
auto l_image = mm->add_literal(migraphx::literal{s_image, gold});
auto l_weights = mm->add_literal(migraphx::literal{s_weights, weights});
mm->add_instruction(
migraphx::make_op("im2col",
......@@ -61,7 +61,7 @@ TEST_CASE(im2col_3x3_no_pad_identity_test)
std::size_t col_width = (size[1] - f[1] + 2 * padding[1]) / stride[1] + 1;
std::vector<float> results_vector(channels * f[0] * f[1] * col_height * col_width);
result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
EXPECT(migraphx::verify::verify_range(results_vector, input));
EXPECT(migraphx::verify::verify_range(results_vector, gold));
}
TEST_CASE(im2col_3x3_no_pad_test)
......@@ -91,14 +91,14 @@ TEST_CASE(im2col_3x3_no_pad_test)
p.compile(migraphx::make_target("ref"));
auto result = p.eval({}).back();
std::vector<int> correct = {0, 1, 2, 4, 5, 6, 8, 9, 10, 1, 2, 3, 5, 6, 7, 9, 10, 11,
std::vector<int> gold = {0, 1, 2, 4, 5, 6, 8, 9, 10, 1, 2, 3, 5, 6, 7, 9, 10, 11,
4, 5, 6, 8, 9, 10, 12, 13, 14, 5, 6, 7, 9, 10, 11, 13, 14, 15};
std::size_t col_height = (size[0] - f[0] + 2 * padding[0]) / stride[0] + 1;
std::size_t col_width = (size[1] - f[1] + 2 * padding[1]) / stride[1] + 1;
std::vector<float> results_vector(channels * f[0] * f[1] * col_height * col_width);
result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
EXPECT(migraphx::verify::verify_range(results_vector, correct));
EXPECT(migraphx::verify::verify_range(results_vector, gold));
}
TEST_CASE(im2col_3x3_stride_2_no_pad_test)
......@@ -128,15 +128,15 @@ TEST_CASE(im2col_3x3_stride_2_no_pad_test)
p.compile(migraphx::make_target("ref"));
auto result = p.eval({}).back();
std::vector<int> correct = {0, 1, 2, 6, 7, 8, 12, 13, 14, 2, 3, 4,
8, 9, 10, 14, 15, 16, 12, 13, 14, 18, 19, 20,
24, 25, 26, 14, 15, 16, 20, 21, 22, 26, 27, 28};
std::vector<int> gold = {0, 1, 2, 6, 7, 8, 12, 13, 14, 2, 3, 4,
8, 9, 10, 14, 15, 16, 12, 13, 14, 18, 19, 20,
24, 25, 26, 14, 15, 16, 20, 21, 22, 26, 27, 28};
std::size_t col_height = (size[0] - f[0] + 2 * padding[0]) / stride[0] + 1;
std::size_t col_width = (size[1] - f[1] + 2 * padding[1]) / stride[1] + 1;
std::vector<float> results_vector(channels * f[0] * f[1] * col_height * col_width);
result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
EXPECT(migraphx::verify::verify_range(results_vector, correct));
EXPECT(migraphx::verify::verify_range(results_vector, gold));
}
TEST_CASE(im2col_3x3_with_channels_identity_test)
......@@ -149,14 +149,14 @@ TEST_CASE(im2col_3x3_with_channels_identity_test)
std::size_t channels = 2;
std::vector<int32_t> weights(channels * f[0] * f[1]);
std::vector<int32_t> input(channels * size[0] * size[1]);
std::iota(input.begin(), input.end(), 0);
std::vector<int32_t> gold(channels * size[0] * size[1]);
std::iota(gold.begin(), gold.end(), 0);
migraphx::program p;
auto* mm = p.get_main_module();
migraphx::shape s_image{migraphx::shape::int32_type, {1, channels, size[0], size[1]}};
migraphx::shape s_weights{migraphx::shape::int32_type, {1, channels, f[0], f[1]}};
auto l_image = mm->add_literal(migraphx::literal{s_image, input});
auto l_image = mm->add_literal(migraphx::literal{s_image, gold});
auto l_weights = mm->add_literal(migraphx::literal{s_weights, weights});
mm->add_instruction(
migraphx::make_op("im2col",
......@@ -170,7 +170,7 @@ TEST_CASE(im2col_3x3_with_channels_identity_test)
std::size_t col_width = (size[1] - f[1] + 2 * padding[1]) / stride[1] + 1;
std::vector<float> results_vector(channels * f[0] * f[1] * col_height * col_width);
result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
EXPECT(migraphx::verify::verify_range(results_vector, input));
EXPECT(migraphx::verify::verify_range(results_vector, gold));
}
TEST_CASE(im2col_3x3_with_padding_test)
......@@ -200,12 +200,12 @@ TEST_CASE(im2col_3x3_with_padding_test)
p.compile(migraphx::make_target("ref"));
auto result = p.eval({}).back();
std::vector<int> correct = {0, 0, 0, 0, 0, 1, 0, 2, 3, 0, 0, 0, 0, 1, 0, 2, 3, 0,
0, 0, 1, 0, 2, 3, 0, 0, 0, 0, 1, 0, 2, 3, 0, 0, 0, 0};
std::vector<int> gold = {0, 0, 0, 0, 0, 1, 0, 2, 3, 0, 0, 0, 0, 1, 0, 2, 3, 0,
0, 0, 1, 0, 2, 3, 0, 0, 0, 0, 1, 0, 2, 3, 0, 0, 0, 0};
std::size_t col_height = (size[0] - f[0] + 2 * padding[0]) / stride[0] + 1;
std::size_t col_width = (size[1] - f[1] + 2 * padding[1]) / stride[1] + 1;
std::vector<float> results_vector(channels * f[0] * f[1] * col_height * col_width);
result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
EXPECT(migraphx::verify::verify_range(results_vector, correct));
EXPECT(migraphx::verify::verify_range(results_vector, gold));
}
test/ref/isnan.cpp
View file @ 4487d4c9
......@@ -45,8 +45,8 @@ TEST_CASE(isnan_test)
auto result = p.eval({}).back();
std::vector<float> results_vector;
result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
std::vector<float> correct = {0, 0, 1, 1, 0, 0};
EXPECT(migraphx::verify::verify_range(results_vector, correct));
std::vector<float> gold = {0, 0, 1, 1, 0, 0};
EXPECT(migraphx::verify::verify_range(results_vector, gold));
}
// half test
......@@ -64,8 +64,8 @@ TEST_CASE(isnan_test)
auto result = p.eval({}).back();
std::vector<float> results_vector;
result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
std::vector<float> correct = {0, 0, 1, 1, 0, 0};
EXPECT(migraphx::verify::verify_range(results_vector, correct));
std::vector<float> gold = {0, 0, 1, 1, 0, 0};
EXPECT(migraphx::verify::verify_range(results_vector, gold));
}
}
......@@ -86,6 +86,6 @@ TEST_CASE(isnan_dyn_test)
auto result = p.eval(params0).back();
std::vector<float> results_vector;
result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
std::vector<float> correct = {0, 0, 1, 1, 0, 0};
EXPECT(migraphx::verify::verify_range(results_vector, correct));
std::vector<float> gold = {0, 0, 1, 1, 0, 0};
EXPECT(migraphx::verify::verify_range(results_vector, gold));
}
test/ref/multinomial.cpp
View file @ 4487d4c9
......@@ -79,5 +79,5 @@ TEST_CASE(multinomial_test)
return static_cast<double>(n) / res_dist_sum;
});
EXPECT(migraphx::verify::verify_range_with_threshold(
res_norm, migraphx::verify::expected{norm}, 0.01));
res_norm, migraphx::verify::expected{norm}, migraphx::verify::threshold{0.01}));
}
test/ref/pooling.cpp
View file @ 4487d4c9
......@@ -565,12 +565,6 @@ TEST_CASE(maxpool_test)
-0.88503587, 0.6629802, 1.47319221, -1.05829155, -0.97027361, -0.93187737, -1.39954746,
-0.52359426, -0.14743951, 1.51522756, 0.2078452, -1.28156149, -1.19363916, -0.78680223,
-0.89094824, 1.30212069, -0.77974445, -0.58411664, 0.48764706, -0.67132682};
std::vector<float> c = {1.33493888, 1.54562736, 1.22098756, 1.33493888, 1.18358743, 1.99097753,
1.00170159, 1.45862222, 1.39087725, 1.46645272, 1.18943918, -0.01443311,
1.47151589, 2.36277103, 2.24768877, 0.68883753, 0.82949388, 0.71550399,
1.95433736, 2.46601582, 1.53285873, 1.95433736, 1.06763375, 1.4545635,
1.33624589, 1.16736257, 0.6126079, 1.36892557, 2.40126371, 1.53441942,
0.52119428, 2.07681108, 0.88494766, 1.51522756, 0.54275119, 0.6629802};
migraphx::shape a_shape{migraphx::shape::float_type, {2, 3, 6, 6}};
auto al = mm->add_literal(migraphx::literal{a_shape, a});
mm->add_instruction(migraphx::make_op("pooling",
......@@ -583,7 +577,15 @@ TEST_CASE(maxpool_test)
auto result = p.eval({}).back();
std::vector<float> results_vector(36);
result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
EXPECT(migraphx::verify::verify_range(results_vector, c));
std::vector<float> gold = {
1.33493888, 1.54562736, 1.22098756, 1.33493888, 1.18358743, 1.99097753,
1.00170159, 1.45862222, 1.39087725, 1.46645272, 1.18943918, -0.01443311,
1.47151589, 2.36277103, 2.24768877, 0.68883753, 0.82949388, 0.71550399,
1.95433736, 2.46601582, 1.53285873, 1.95433736, 1.06763375, 1.4545635,
1.33624589, 1.16736257, 0.6126079, 1.36892557, 2.40126371, 1.53441942,
0.52119428, 2.07681108, 0.88494766, 1.51522756, 0.54275119, 0.6629802};
EXPECT(migraphx::verify::verify_range(results_vector, gold));
}
TEST_CASE(maxpool_pad_test)
......@@ -591,7 +593,6 @@ TEST_CASE(maxpool_pad_test)
migraphx::program p;
auto* mm = p.get_main_module();
std::vector<float> a = {-6, -5, -4, -3, -5, -1, 0, 1, 2, 3, 4, 5};
std::vector<float> c = {-4, -3, -4, -1, 2, 3, 4, 5};
migraphx::shape a_shape{migraphx::shape::float_type, {1, 2, 3, 2}};
auto al = mm->add_literal(migraphx::literal{a_shape, a});
mm->add_instruction(migraphx::make_op("pooling",
......@@ -611,8 +612,8 @@ TEST_CASE(maxpool_pad_test)
auto result = p.eval({}).back();
std::vector<float> results_vector(8);
result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
EXPECT(migraphx::verify::verify_range(results_vector, c));
std::vector<float> gold = {-4, -3, -4, -1, 2, 3, 4, 5};
EXPECT(migraphx::verify::verify_range(results_vector, gold));
}
TEST_CASE(maxpool_rank3_test0)
......
test/ref/quant_convolution.cpp
View file @ 4487d4c9
......@@ -47,7 +47,7 @@ TEST_CASE(quant_conv2d_padding_stride_test)
p.compile(migraphx::make_target("ref"));
auto result = p.eval({}).back();
std::vector<int32_t> s = {4521,
std::vector<int32_t> gold = {4521,
7014,
7830,
11952,
......@@ -65,7 +65,7 @@ TEST_CASE(quant_conv2d_padding_stride_test)
82746};
std::vector<int32_t> results_vector;
result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
EXPECT(migraphx::verify::verify_range(results_vector, s));
EXPECT(migraphx::verify::verify_range(results_vector, gold));
}
TEST_CASE(quant_conv2d_padding_test)
......@@ -83,8 +83,8 @@ TEST_CASE(quant_conv2d_padding_test)
mm->add_instruction(
migraphx::make_op("quant_convolution", {{"padding", {1, 1}}, {"stride", {1, 1}}}), al, cl);
p.compile(migraphx::make_target("ref"));
auto result = p.eval({}).back();
std::vector<int32_t> s = {
auto result = p.eval({}).back();
std::vector<int32_t> gold = {
4521, 6753, 7014, 4635, 6858, 10197, 10548, 6939, 7830, 11601, 11952, 7839, 5007,
7383, 7590, 4953, 10515, 15987, 16734, 11277, 16821, 25506, 26586, 17874, 19737, 29826,
30906, 20718, 13593, 20505, 21198, 14187, 13161, 19281, 19542, 12699, 18522, 27045, 27396,
......@@ -93,7 +93,7 @@ TEST_CASE(quant_conv2d_padding_test)
std::vector<int32_t> results_vector;
result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
EXPECT(migraphx::verify::verify_range(results_vector, s));
EXPECT(migraphx::verify::verify_range(results_vector, gold));
}
TEST_CASE(quant_conv2d_test)
......@@ -114,24 +114,24 @@ TEST_CASE(quant_conv2d_test)
p.compile(migraphx::make_target("ref"));
auto result = p.eval({}).back();
std::vector<int32_t> s = {10197,
10548,
11601,
11952,
25506,
26586,
29826,
30906,
27045,
27396,
28449,
28800,
77346,
78426,
81666,
82746};
std::vector<int32_t> gold = {10197,
10548,
11601,
11952,
25506,
26586,
29826,
30906,
27045,
27396,
28449,
28800,
77346,
78426,
81666,
82746};
std::vector<int32_t> results_vector;
result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
EXPECT(migraphx::verify::verify_range(results_vector, s));
EXPECT(migraphx::verify::verify_range(results_vector, gold));
}
test/ref/random_uniform.cpp
View file @ 4487d4c9
......@@ -68,8 +68,9 @@ TEST_CASE(random_uniform_test)
std::uniform_real_distribution<> dis(0.0, 1.0);
std::vector<float> rand_samples(sample_size);
std::generate(rand_samples.begin(), rand_samples.end(), [&]() { return dis(gen); });
EXPECT(migraphx::verify::verify_range_with_threshold(
result_vec, migraphx::verify::expected{rand_samples}, 0.00001));
EXPECT(migraphx::verify::verify_range_with_threshold(result_vec,
migraphx::verify::expected{rand_samples},
migraphx::verify::threshold{0.00001}));
}
TEST_CASE(random_uniform_int_test)
......@@ -103,9 +104,9 @@ TEST_CASE(random_uniform_int_test)
// Compare result with the STL's mt19937 generator
std::mt19937 gen(seed);
std::uniform_int_distribution<uint16_t> dis;
std::vector<uint16_t> rand_samples(sample_size);
std::generate(rand_samples.begin(), rand_samples.end(), [&]() { return dis(gen); });
EXPECT(migraphx::verify::verify_range(result_vec, rand_samples));
std::vector<uint16_t> gold_rand_samples(sample_size);
std::generate(gold_rand_samples.begin(), gold_rand_samples.end(), [&]() { return dis(gen); });
EXPECT(migraphx::verify::verify_range(result_vec, gold_rand_samples));
}
TEST_CASE(random_uniform_dyn_test)
......@@ -142,9 +143,9 @@ TEST_CASE(random_uniform_dyn_test)
// Compare result with the STL's mt19937 generator
std::mt19937 gen(seed);
std::uniform_real_distribution<> dis(0.0, 1.0);
std::vector<float> rand_samples(sample_size);
std::generate(rand_samples.begin(), rand_samples.end(), [&]() { return dis(gen); });
EXPECT(migraphx::verify::verify_range(result_vec, rand_samples));
std::vector<float> gold_rand_samples(sample_size);
std::generate(gold_rand_samples.begin(), gold_rand_samples.end(), [&]() { return dis(gen); });
EXPECT(migraphx::verify::verify_range(result_vec, gold_rand_samples));
}
TEST_CASE(random_uniform_and_seed_test)
......
test/ref/reshape.cpp
View file @ 4487d4c9
......@@ -33,52 +33,52 @@
TEST_CASE(reshape_test0)
{
migraphx::shape a_shape{migraphx::shape::float_type, {24, 1, 1, 1}};
std::vector<float> data(24);
std::iota(data.begin(), data.end(), -3);
std::vector<float> gold(24);
std::iota(gold.begin(), gold.end(), -3);
migraphx::program p;
auto* mm = p.get_main_module();
auto l = mm->add_literal(migraphx::literal{a_shape, data});
auto l = mm->add_literal(migraphx::literal{a_shape, gold});
std::vector<int64_t> new_shape = {8, 3, 1, 1};
mm->add_instruction(migraphx::make_op("reshape", {{"dims", new_shape}}), l);
p.compile(migraphx::make_target("ref"));
auto result = p.eval({}).back();
std::vector<float> results_vector{};
result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
EXPECT(migraphx::verify::verify_range(results_vector, data));
EXPECT(migraphx::verify::verify_range(results_vector, gold));
}
TEST_CASE(reshape_test1)
{
migraphx::shape a_shape{migraphx::shape::float_type, {24, 1, 1, 1}};
std::vector<float> data(24);
std::iota(data.begin(), data.end(), -3);
std::vector<float> gold(24);
std::iota(gold.begin(), gold.end(), -3);
migraphx::program p;
auto* mm = p.get_main_module();
auto l = mm->add_literal(migraphx::literal{a_shape, data});
auto l = mm->add_literal(migraphx::literal{a_shape, gold});
std::vector<int64_t> new_shape = {1, 3, 4, 2};
mm->add_instruction(migraphx::make_op("reshape", {{"dims", new_shape}}), l);
p.compile(migraphx::make_target("ref"));
auto result = p.eval({}).back();
std::vector<float> results_vector{};
result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
EXPECT(migraphx::verify::verify_range(results_vector, data));
EXPECT(migraphx::verify::verify_range(results_vector, gold));
}
TEST_CASE(reshape_test2)
{
migraphx::shape a_shape{migraphx::shape::float_type, {24, 1, 1, 1}};
std::vector<float> data(24);
std::iota(data.begin(), data.end(), -3);
std::vector<float> gold(24);
std::iota(gold.begin(), gold.end(), -3);
migraphx::program p;
auto* mm = p.get_main_module();
auto l = mm->add_literal(migraphx::literal{a_shape, data});
auto l = mm->add_literal(migraphx::literal{a_shape, gold});
std::vector<int64_t> new_shape = {1, 2, 3, 4};
mm->add_instruction(migraphx::make_op("reshape", {{"dims", new_shape}}), l);
p.compile(migraphx::make_target("ref"));
auto result = p.eval({}).back();
std::vector<float> results_vector{};
result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
EXPECT(migraphx::verify::verify_range(results_vector, data));
EXPECT(migraphx::verify::verify_range(results_vector, gold));
}
TEST_CASE(reshape_dyn_test)
......@@ -91,13 +91,13 @@ TEST_CASE(reshape_dyn_test)
mm->add_instruction(migraphx::make_op("reshape", {{"dims", new_shape}}), input);
p.compile(migraphx::make_target("ref"));
std::vector<float> data(48);
std::iota(data.begin(), data.end(), -3);
std::vector<float> gold(48);
std::iota(gold.begin(), gold.end(), -3);
migraphx::parameter_map params;
migraphx::shape input_fixed_shape{migraphx::shape::float_type, {2, 24, 1, 1}};
params["X"] = migraphx::argument(input_fixed_shape, data.data());
params["X"] = migraphx::argument(input_fixed_shape, gold.data());
auto result = p.eval(params).back();
std::vector<float> results_vector{};
result.visit([&](auto output) { results_vector.assign(output.begin(), output.end()); });
EXPECT(migraphx::verify::verify_range(results_vector, data));
EXPECT(migraphx::verify::verify_range(results_vector, gold));
}
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment