megenginelite-sys 1.8.2

A safe megenginelite wrapper in Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112

/**
 * \file src/opr/test/standalone/nms.cpp
 *
 * Copyright (c) 2014-2021 Megvii Inc. All rights reserved.
 */

#include <random>
#include "megbrain/opr/io.h"
#include "megbrain/opr/standalone/nms_opr.h"
#include "megbrain/opr/tensor_gen.h"
#include "megbrain/opr/tensor_manip.h"
#include "megbrain/test/helper.h"

using namespace mgb;

namespace {

void run_on_comp_node(const char* cn_name) {
    auto cn = CompNode::load(cn_name);
    auto graph = ComputingGraph::make();
    auto host_x =
            std::make_shared<HostTensorND>(cn, TensorShape{1, 2, 4}, dtype::Float32{});
    auto ptr = host_x->ptr<float>();
    ptr[0] = 0.;
    ptr[1] = 0.;
    ptr[2] = 2.;
    ptr[3] = 2.;
    ptr[4] = 0.5;
    ptr[5] = 0.5;
    ptr[6] = 1.5;
    ptr[7] = 1.5;

    auto x = opr::Host2DeviceCopy::make(*graph, host_x);

    {
        auto idx = opr::standalone::NMSKeep::make(x, {0.2, 16});
        auto size = idx.node()->owner_opr()->output(1);
        HostTensorND host_idx, host_size;
        auto func = graph->compile(
                {make_callback_copy(idx, host_idx),
                 make_callback_copy(size, host_size)});
        func->execute().wait();
        auto idx_ptr = host_idx.ptr<int32_t>();
        auto size_ptr = host_size.ptr<int32_t>();
        ASSERT_EQ(size_ptr[0], 1);
        ASSERT_EQ(idx_ptr[0], 0);
    }
    {
        auto idx = opr::standalone::NMSKeep::make(x, {0.5, 16});
        auto size = idx.node()->owner_opr()->output(1);
        HostTensorND host_idx, host_size;
        auto func = graph->compile(
                {make_callback_copy(idx, host_idx),
                 make_callback_copy(size, host_size)});
        func->execute().wait();
        auto idx_ptr = host_idx.ptr<int32_t>();
        auto size_ptr = host_size.ptr<int32_t>();
        ASSERT_EQ(size_ptr[0], 2);
        ASSERT_EQ(idx_ptr[0], 0);
        ASSERT_EQ(idx_ptr[1], 1);
    }
}

void run_empty_input_on_comp_node(const char* cn_name) {
    auto cn = CompNode::load(cn_name);
    auto graph = ComputingGraph::make();
    auto host_x =
            std::make_shared<HostTensorND>(cn, TensorShape{1, 0, 4}, dtype::Float32{});
    auto x = opr::Host2DeviceCopy::make(*graph, host_x);

    {
        auto idx = opr::standalone::NMSKeep::make(x, {0.2, 16});
        auto size = idx.node()->owner_opr()->output(1);
        HostTensorND host_idx, host_size;
        auto func = graph->compile(
                {make_callback_copy(idx, host_idx),
                 make_callback_copy(size, host_size)});
        func->execute().wait();
        auto size_ptr = host_size.ptr<int32_t>();
        ASSERT_EQ(size_ptr[0], 0);
    }
}

}  // namespace

TEST(TestOprNMS, CPU) {
    run_on_comp_node("cpu0");
}

TEST(TestOprNMS, GPU) {
    REQUIRE_GPU(1);
    run_on_comp_node("gpu0");
}

TEST(TestOprNMSEmptyIO, CPU) {
    run_empty_input_on_comp_node("cpu0");
}

TEST(TestOprNMSEmptyIO, GPU) {
    REQUIRE_GPU(1);
    run_empty_input_on_comp_node("gpu0");
}

#if MGB_ENABLE_EXCEPTION
TEST(TestOprNMS, InvalidInput) {
    HostTensorGenerator<> gen;
    auto graph = ComputingGraph::make();
    auto host_x = gen({1, 9, 5});
    auto x = opr::Host2DeviceCopy::make(*graph, host_x);
    ASSERT_ANY_THROW(opr::standalone::NMSKeep::make(x, {1., 1}));
}
#endif  // MGB_ENABLE_EXCEPTION