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
|
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include <armnnDeserializer/IDeserializer.hpp>
#include <armnn/ArmNN.hpp>
#include <armnn/INetwork.hpp>
#include "../Serializer.hpp"
#include <sstream>
#include <boost/core/ignore_unused.hpp>
#include <boost/test/unit_test.hpp>
BOOST_AUTO_TEST_SUITE(SerializerTests)
class VerifyActivationName : public armnn::LayerVisitorBase<armnn::VisitorNoThrowPolicy>
{
public:
void VisitActivationLayer(const armnn::IConnectableLayer* layer,
const armnn::ActivationDescriptor& activationDescriptor,
const char* name) override
{
boost::ignore_unused(layer, activationDescriptor);
BOOST_TEST(name == "activation");
}
};
BOOST_AUTO_TEST_CASE(ActivationSerialization)
{
armnnDeserializer::IDeserializerPtr parser = armnnDeserializer::IDeserializer::Create();
armnn::TensorInfo inputInfo(armnn::TensorShape({1, 2, 2, 1}), armnn::DataType::Float32, 1.0f, 0);
armnn::TensorInfo outputInfo(armnn::TensorShape({1, 2, 2, 1}), armnn::DataType::Float32, 4.0f, 0);
// Construct network
armnn::INetworkPtr network = armnn::INetwork::Create();
armnn::ActivationDescriptor descriptor;
descriptor.m_Function = armnn::ActivationFunction::ReLu;
descriptor.m_A = 0;
descriptor.m_B = 0;
armnn::IConnectableLayer* const inputLayer = network->AddInputLayer(0, "input");
armnn::IConnectableLayer* const activationLayer = network->AddActivationLayer(descriptor, "activation");
armnn::IConnectableLayer* const outputLayer = network->AddOutputLayer(0, "output");
inputLayer->GetOutputSlot(0).Connect(activationLayer->GetInputSlot(0));
inputLayer->GetOutputSlot(0).SetTensorInfo(inputInfo);
activationLayer->GetOutputSlot(0).Connect(outputLayer->GetInputSlot(0));
activationLayer->GetOutputSlot(0).SetTensorInfo(outputInfo);
armnnSerializer::Serializer serializer;
serializer.Serialize(*network);
std::stringstream stream;
serializer.SaveSerializedToStream(stream);
std::string const serializerString{stream.str()};
std::vector<std::uint8_t> const serializerVector{serializerString.begin(), serializerString.end()};
armnn::INetworkPtr deserializedNetwork = parser->CreateNetworkFromBinary(serializerVector);
VerifyActivationName visitor;
deserializedNetwork->Accept(visitor);
armnn::IRuntime::CreationOptions options; // default options
armnn::IRuntimePtr run = armnn::IRuntime::Create(options);
auto deserializedOptimized = Optimize(*deserializedNetwork, { armnn::Compute::CpuRef }, run->GetDeviceSpec());
armnn::NetworkId networkIdentifier;
// Load graph into runtime
run->LoadNetwork(networkIdentifier, std::move(deserializedOptimized));
std::vector<float> inputData {0.0f, -5.3f, 42.0f, -42.0f};
armnn::InputTensors inputTensors
{
{0, armnn::ConstTensor(run->GetInputTensorInfo(networkIdentifier, 0), inputData.data())}
};
std::vector<float> expectedOutputData {0.0f, 0.0f, 42.0f, 0.0f};
std::vector<float> outputData(4);
armnn::OutputTensors outputTensors
{
{0, armnn::Tensor(run->GetOutputTensorInfo(networkIdentifier, 0), outputData.data())}
};
run->EnqueueWorkload(networkIdentifier, inputTensors, outputTensors);
BOOST_CHECK_EQUAL_COLLECTIONS(outputData.begin(), outputData.end(),
expectedOutputData.begin(), expectedOutputData.end());
}
BOOST_AUTO_TEST_SUITE_END()
|
