xref: /aosp_15_r20/external/armnn/delegate/test/TransposeTestHelper.hpp (revision 89c4ff92f2867872bb9e2354d150bf0c8c502810)
1 //
2 // Copyright © 2020, 2023 Arm Ltd and Contributors. All rights reserved.
3 // SPDX-License-Identifier: MIT
4 //
5 
6 #pragma once
7 
8 #include "TestUtils.hpp"
9 
10 #include <armnn_delegate.hpp>
11 #include <DelegateTestInterpreter.hpp>
12 
13 #include <flatbuffers/flatbuffers.h>
14 #include <tensorflow/lite/kernels/register.h>
15 #include <tensorflow/lite/version.h>
16 
17 #include <schema_generated.h>
18 
19 #include <doctest/doctest.h>
20 
21 namespace
22 {
CreateTransposeTfLiteModel(tflite::TensorType tensorType,const std::vector<int32_t> & input0TensorShape,const std::vector<int32_t> & inputPermVecShape,const std::vector<int32_t> & outputTensorShape,const std::vector<int32_t> & inputPermVec)23 std::vector<char> CreateTransposeTfLiteModel(tflite::TensorType tensorType,
24                                              const std::vector <int32_t>& input0TensorShape,
25                                              const std::vector <int32_t>& inputPermVecShape,
26                                              const std::vector <int32_t>& outputTensorShape,
27                                              const std::vector<int32_t>& inputPermVec)
28 {
29     using namespace tflite;
30     flatbuffers::FlatBufferBuilder flatBufferBuilder;
31     flatbuffers::Offset<tflite::Buffer> buffers[4]{
32             CreateBuffer(flatBufferBuilder),
33             CreateBuffer(flatBufferBuilder),
34             CreateBuffer(flatBufferBuilder,
35                          flatBufferBuilder.CreateVector(reinterpret_cast<const uint8_t*>(inputPermVec.data()),
36                                                         sizeof(int32_t) * inputPermVec.size())),
37             CreateBuffer(flatBufferBuilder)
38     };
39     std::array<flatbuffers::Offset<Tensor>, 3> tensors;
40     tensors[0] = CreateTensor(flatBufferBuilder,
41                               flatBufferBuilder.CreateVector<int32_t>(input0TensorShape.data(),
42                                                                       input0TensorShape.size()),
43                               tensorType, 1);
44     tensors[1] = CreateTensor(flatBufferBuilder,
45                               flatBufferBuilder.CreateVector<int32_t>(inputPermVecShape.data(),
46                                                                       inputPermVecShape.size()),
47                               tflite::TensorType_INT32, 2,
48                               flatBufferBuilder.CreateString("permutation_vector"));
49     tensors[2] = CreateTensor(flatBufferBuilder,
50                               flatBufferBuilder.CreateVector<int32_t>(outputTensorShape.data(),
51                                                                       outputTensorShape.size()),
52                               tensorType,3);
53     const std::vector<int32_t> operatorInputs{0, 1};
54     const std::vector<int32_t> operatorOutputs{2};
55     flatbuffers::Offset <Operator> transposeOperator =
56             CreateOperator(flatBufferBuilder,
57                            0,
58                            flatBufferBuilder.CreateVector<int32_t>(operatorInputs.data(), operatorInputs.size()),
59                            flatBufferBuilder.CreateVector<int32_t>(operatorOutputs.data(), operatorOutputs.size()),
60                            BuiltinOptions_TransposeOptions,
61                            CreateTransposeOptions(flatBufferBuilder).Union());
62     const std::vector<int> subgraphInputs{0, 1};
63     const std::vector<int> subgraphOutputs{2};
64     flatbuffers::Offset <SubGraph> subgraph =
65             CreateSubGraph(flatBufferBuilder,
66                            flatBufferBuilder.CreateVector(tensors.data(), tensors.size()),
67                            flatBufferBuilder.CreateVector<int32_t>(subgraphInputs.data(), subgraphInputs.size()),
68                            flatBufferBuilder.CreateVector<int32_t>(subgraphOutputs.data(), subgraphOutputs.size()),
69                            flatBufferBuilder.CreateVector(&transposeOperator, 1));
70     flatbuffers::Offset <flatbuffers::String> modelDescription =
71             flatBufferBuilder.CreateString("ArmnnDelegate: Transpose Operator Model");
72     flatbuffers::Offset <OperatorCode> operatorCode = CreateOperatorCode(flatBufferBuilder,
73                                                                          tflite::BuiltinOperator_TRANSPOSE);
74     flatbuffers::Offset <Model> flatbufferModel =
75             CreateModel(flatBufferBuilder,
76                         TFLITE_SCHEMA_VERSION,
77                         flatBufferBuilder.CreateVector(&operatorCode, 1),
78                         flatBufferBuilder.CreateVector(&subgraph, 1),
79                         modelDescription,
80                         flatBufferBuilder.CreateVector(buffers, 4));
81     flatBufferBuilder.Finish(flatbufferModel, armnnDelegate::FILE_IDENTIFIER);
82     return std::vector<char>(flatBufferBuilder.GetBufferPointer(),
83                              flatBufferBuilder.GetBufferPointer() + flatBufferBuilder.GetSize());
84 }
85 
86 template <typename T>
TransposeTest(std::vector<armnn::BackendId> & backends,std::vector<int32_t> & inputShape,std::vector<int32_t> & inputPermVecShape,std::vector<int32_t> & outputShape,std::vector<T> & inputValues,std::vector<int32_t> & inputPermVec,std::vector<T> & expectedOutputValues)87 void TransposeTest(std::vector<armnn::BackendId>& backends,
88                    std::vector<int32_t>& inputShape,
89                    std::vector<int32_t>& inputPermVecShape,
90                    std::vector<int32_t>& outputShape,
91                    std::vector<T>& inputValues,
92                    std::vector<int32_t>& inputPermVec,
93                    std::vector<T>& expectedOutputValues)
94 {
95     using namespace delegateTestInterpreter;
96 
97     // Create model
98     std::vector<char> modelBuffer = CreateTransposeTfLiteModel(::tflite::TensorType_FLOAT32,
99                                                                inputShape,
100                                                                inputPermVecShape,
101                                                                outputShape,
102                                                                inputPermVec);
103 
104     // Setup interpreter with just TFLite Runtime.
105     auto tfLiteInterpreter = DelegateTestInterpreter(modelBuffer);
106     CHECK(tfLiteInterpreter.AllocateTensors() == kTfLiteOk);
107     CHECK(tfLiteInterpreter.FillInputTensor<T>(inputValues, 0) == kTfLiteOk);
108     CHECK(tfLiteInterpreter.FillInputTensor<int32_t>(inputPermVec, 1) == kTfLiteOk);
109     CHECK(tfLiteInterpreter.Invoke() == kTfLiteOk);
110     std::vector<T>       tfLiteOutputValues = tfLiteInterpreter.GetOutputResult<T>(0);
111     std::vector<int32_t> tfLiteOutputShape  = tfLiteInterpreter.GetOutputShape(0);
112 
113     // Setup interpreter with Arm NN Delegate applied.
114     auto armnnInterpreter = DelegateTestInterpreter(modelBuffer, backends);
115     CHECK(armnnInterpreter.AllocateTensors() == kTfLiteOk);
116     CHECK(armnnInterpreter.FillInputTensor<T>(inputValues, 0) == kTfLiteOk);
117     CHECK(armnnInterpreter.FillInputTensor<int32_t>(inputPermVec, 1) == kTfLiteOk);
118     CHECK(armnnInterpreter.Invoke() == kTfLiteOk);
119     std::vector<T>       armnnOutputValues = armnnInterpreter.GetOutputResult<T>(0);
120     std::vector<int32_t> armnnOutputShape  = armnnInterpreter.GetOutputShape(0);
121 
122     armnnDelegate::CompareOutputData<T>(tfLiteOutputValues, armnnOutputValues, expectedOutputValues);
123     armnnDelegate::CompareOutputShape(tfLiteOutputShape, armnnOutputShape, outputShape);
124 
125     tfLiteInterpreter.Cleanup();
126     armnnInterpreter.Cleanup();
127 }
128 }
129