src/armnnDeserializer/test/DeserializeLogSoftmax.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
115
116
117
118
119
120
121
122
123
124
125
126

//
// Copyright © 2019 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//

#include "ParserFlatbuffersSerializeFixture.hpp"
#include <armnnDeserializer/IDeserializer.hpp>

TEST_SUITE("Deserializer_LogSoftmax")
{
struct LogSoftmaxFixture : public ParserFlatbuffersSerializeFixture
{
    explicit LogSoftmaxFixture(const std::string &shape,
                               const std::string &beta,
                               const std::string &axis,
                               const std::string &dataType)
    {
        m_JsonString = R"(
        {
            inputIds: [0],
            outputIds: [2],
            layers: [
                {
                layer_type: "InputLayer",
                layer: {
                    base: {
                        layerBindingId: 0,
                        base: {
                            index: 0,
                            layerName: "InputLayer",
                            layerType: "Input",
                            inputSlots: [{
                                index: 0,
                                connection: { sourceLayerIndex:0, outputSlotIndex:0 },
                                }],
                            outputSlots: [{
                                index: 0,
                                tensorInfo: {
                                    dimensions: )" + shape + R"(,
                                    dataType: ")" + dataType + R"(",
                                    quantizationScale: 0.5,
                                    quantizationOffset: 0
                                    },
                                }]
                            },
                        }
                    },
                },
            {
            layer_type: "LogSoftmaxLayer",
            layer : {
                base: {
                    index:1,
                    layerName: "LogSoftmaxLayer",
                    layerType: "LogSoftmax",
                    inputSlots: [{
                            index: 0,
                            connection: { sourceLayerIndex:0, outputSlotIndex:0 },
                        }],
                    outputSlots: [{
                        index: 0,
                        tensorInfo: {
                            dimensions: )" + shape + R"(,
                            dataType: ")" + dataType + R"("
                        },
                        }],
                    },
                descriptor: {
                    beta: ")" + beta + R"(",
                    axis: )" + axis + R"(
                    },
                },
            },
            {
            layer_type: "OutputLayer",
            layer: {
                base:{
                    layerBindingId: 0,
                    base: {
                        index: 2,
                        layerName: "OutputLayer",
                        layerType: "Output",
                        inputSlots: [{
                            index: 0,
                            connection: { sourceLayerIndex:1, outputSlotIndex:0 },
                        }],
                        outputSlots: [ {
                            index: 0,
                            tensorInfo: {
                                dimensions: )" + shape + R"(,
                                dataType: ")" + dataType + R"("
                            },
                        }],
                    }
                }},
            }]
        })";
        SetupSingleInputSingleOutput("InputLayer", "OutputLayer");
    }
};

struct LogSoftmaxFloat32Fixture : LogSoftmaxFixture
{
    LogSoftmaxFloat32Fixture() :
        LogSoftmaxFixture("[ 1, 1, 2, 4 ]", // inputShape
                          "1.0",            // beta
                          "3",              // axis
                          "Float32")        // dataType
    {}
};

TEST_CASE_FIXTURE(LogSoftmaxFloat32Fixture, "LogSoftmaxFloat32")
{
    RunTest<4, armnn::DataType::Float32>(
        0,
        {
            0.f, -6.f,  2.f, 4.f,
            3.f, -2.f, 10.f, 1.f
        },
        {
            -4.14297f, -10.14297f, -2.14297f, -0.14297f,
            -7.00104f, -12.00104f, -0.00105f, -9.00104f
        });
}

}