src/armnnTfLiteParser/test/BatchMatMul.cpp


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
113
114

//
// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//

#include "ParserFlatbuffersFixture.hpp"

TEST_SUITE("TensorflowLiteParser_BatchMatMul")
{
struct BatchMatMulFixture : public ParserFlatbuffersFixture
{
    explicit BatchMatMulFixture(const std::string &inputXShape,
                                const std::string &inputYShape,
                                const std::string &outputShape,
                                const std::string &adjX,
                                const std::string &adjY)
    {
        m_JsonString = R"(
            {
                "version": 3,
                "operator_codes": [ { "builtin_code": "BATCH_MATMUL" } ],
                "subgraphs": [
                    {
                        "tensors": [
                            {
                                "shape": )" + inputXShape + R"(,
                                "type": "FLOAT32",
                                "buffer": 0,
                                "name": "inputXTensor",
                                "quantization": {
                                    "min": [ 0.0 ],
                                    "max": [ 255.0 ],
                                    "scale": [ 1.0 ],
                                    "zero_point": [ 0 ],
                                }
                            },
                            {
                                "shape": )" + inputYShape + R"(,
                                "type": "FLOAT32",
                                "buffer": 1,
                                "name": "inputYTensor",
                                "quantization": {
                                    "min": [ 0.0 ],
                                    "max": [ 255.0 ],
                                    "scale": [ 1.0 ],
                                    "zero_point": [ 0 ],
                                }
                            },
                            {
                                "shape": )" + outputShape + R"(,
                                "type": "FLOAT32",
                                "buffer": 2,
                                "name": "outputTensor",
                                "quantization": {
                                    "min": [ 0.0 ],
                                    "max": [ 255.0 ],
                                    "scale": [ 1.0 ],
                                    "zero_point": [ 0 ],
                                }
                            }
                        ],
                        "inputs": [ 0, 1 ],
                        "outputs": [ 2 ],
                        "operators": [
                            {
                                "opcode_index": 0,
                                "inputs": [ 0 , 1 ],
                                "outputs": [ 2 ],
                                "builtin_options_type": "BatchMatMulOptions",
                                "builtin_options": {
                                    adj_x: )" + adjX + R"(,
                                    adj_y: )" + adjY + R"(,
                                    "asymmetric_quantize_inputs": false
                                },
                                "custom_options_format": "FLEXBUFFERS"
                            }
                        ]
                    }
                ],
                "buffers": [{},{}]
            }
        )";
        Setup();
    }
};

struct BatchMatMulParamsFixture : BatchMatMulFixture
{
    BatchMatMulParamsFixture()
        : BatchMatMulFixture("[ 1, 3, 3 ]",
                             "[ 1, 3, 3 ]",
                             "[ 1, 3, 3 ]",
                             "false",
                             "true")
    {}
};

TEST_CASE_FIXTURE(BatchMatMulParamsFixture, "ParseBatchMatMulParams")
{
    RunTest<3, armnn::DataType::Float32>(
        0,
        {{"inputXTensor", {2.0f, 3.0f, 5.0f,
                           8.0f, 13.0f, 21.0f,
                           34.0f, 55.0f, 89.0f}},
         {"inputYTensor", {0.0f, 1.0f, 1.0f,
                           1.0f, 0.0f, 1.0f,
                           1.0f, 1.0f, 0.0f}}},
        {{"outputTensor", {6.0f, 4.0f, 0.0f,
                           26.0f, 16.0f, 0.0f,
                           110.0f, 68.0f, 0.0f}}}
        );
}

}