ArmNN
 21.02
ConstTensorLayerVisitor.cpp
Go to the documentation of this file.
1 //
2 // Copyright © 2017 Arm Ltd. All rights reserved.
3 // SPDX-License-Identifier: MIT
4 //
5 
6 #include "ConstTensorLayerVisitor.hpp"
7 #include "Network.hpp"
8 
9 #include <boost/test/unit_test.hpp>
10 
11 namespace armnn
12 {
13 
14 void TestConvolution2dLayerVisitor::CheckDescriptor(const Convolution2dDescriptor &convolution2dDescriptor)
15 {
16  BOOST_CHECK(m_Descriptor.m_PadLeft == convolution2dDescriptor.m_PadLeft);
17  BOOST_CHECK(m_Descriptor.m_PadRight == convolution2dDescriptor.m_PadRight);
18  BOOST_CHECK(m_Descriptor.m_PadTop == convolution2dDescriptor.m_PadTop);
19  BOOST_CHECK(m_Descriptor.m_PadBottom == convolution2dDescriptor.m_PadBottom);
20  BOOST_CHECK(m_Descriptor.m_StrideX == convolution2dDescriptor.m_StrideX);
21  BOOST_CHECK(m_Descriptor.m_StrideY == convolution2dDescriptor.m_StrideY);
22  BOOST_CHECK(m_Descriptor.m_BiasEnabled == convolution2dDescriptor.m_BiasEnabled);
23  BOOST_CHECK(m_Descriptor.m_DataLayout == convolution2dDescriptor.m_DataLayout);
24 }
25 
26 void TestDepthwiseConvolution2dLayerVisitor::CheckDescriptor(
27  const DepthwiseConvolution2dDescriptor& convolution2dDescriptor)
28 {
29  BOOST_CHECK(m_Descriptor.m_PadLeft == convolution2dDescriptor.m_PadLeft);
30  BOOST_CHECK(m_Descriptor.m_PadRight == convolution2dDescriptor.m_PadRight);
31  BOOST_CHECK(m_Descriptor.m_PadTop == convolution2dDescriptor.m_PadTop);
32  BOOST_CHECK(m_Descriptor.m_PadBottom == convolution2dDescriptor.m_PadBottom);
33  BOOST_CHECK(m_Descriptor.m_StrideX == convolution2dDescriptor.m_StrideX);
34  BOOST_CHECK(m_Descriptor.m_StrideY == convolution2dDescriptor.m_StrideY);
35  BOOST_CHECK(m_Descriptor.m_BiasEnabled == convolution2dDescriptor.m_BiasEnabled);
36  BOOST_CHECK(m_Descriptor.m_DataLayout == convolution2dDescriptor.m_DataLayout);
37 }
38 
39 void TestFullyConnectedLayerVistor::CheckDescriptor(const FullyConnectedDescriptor& descriptor)
40 {
41  BOOST_CHECK(m_Descriptor.m_BiasEnabled == descriptor.m_BiasEnabled);
42  BOOST_CHECK(m_Descriptor.m_TransposeWeightMatrix == descriptor.m_TransposeWeightMatrix);
43 }
44 
45 void TestBatchNormalizationLayerVisitor::CheckDescriptor(const BatchNormalizationDescriptor& descriptor)
46 {
47  BOOST_CHECK(m_Descriptor.m_Eps == descriptor.m_Eps);
48  BOOST_CHECK(m_Descriptor.m_DataLayout == descriptor.m_DataLayout);
49 }
50 
51 void TestLstmLayerVisitor::CheckDescriptor(const LstmDescriptor& descriptor)
52 {
53  BOOST_CHECK(m_Descriptor.m_ActivationFunc == descriptor.m_ActivationFunc);
54  BOOST_CHECK(m_Descriptor.m_ClippingThresCell == descriptor.m_ClippingThresCell);
55  BOOST_CHECK(m_Descriptor.m_ClippingThresProj == descriptor.m_ClippingThresProj);
56  BOOST_CHECK(m_Descriptor.m_CifgEnabled == descriptor.m_CifgEnabled);
57  BOOST_CHECK(m_Descriptor.m_PeepholeEnabled == descriptor.m_PeepholeEnabled);
58  BOOST_CHECK(m_Descriptor.m_ProjectionEnabled == descriptor.m_ProjectionEnabled);
59 }
60 
61 void TestLstmLayerVisitor::CheckConstTensorPtrs(const std::string& name,
62  const ConstTensor* expected,
63  const ConstTensor* actual)
64 {
65  if (expected == nullptr)
66  {
67  BOOST_CHECK_MESSAGE(actual == nullptr, name + " actual should have been a nullptr");
68  }
69  else
70  {
71  BOOST_CHECK_MESSAGE(actual != nullptr, name + " actual should have been set");
72  if (actual != nullptr)
73  {
74  CheckConstTensors(*expected, *actual);
75  }
76  }
77 }
78 
79 void TestLstmLayerVisitor::CheckInputParameters(const LstmInputParams& inputParams)
80 {
81  CheckConstTensorPtrs("ProjectionBias", m_InputParams.m_ProjectionBias, inputParams.m_ProjectionBias);
82  CheckConstTensorPtrs("ProjectionWeights", m_InputParams.m_ProjectionWeights, inputParams.m_ProjectionWeights);
83  CheckConstTensorPtrs("OutputGateBias", m_InputParams.m_OutputGateBias, inputParams.m_OutputGateBias);
84  CheckConstTensorPtrs("InputToInputWeights",
85  m_InputParams.m_InputToInputWeights, inputParams.m_InputToInputWeights);
86  CheckConstTensorPtrs("InputToForgetWeights",
87  m_InputParams.m_InputToForgetWeights, inputParams.m_InputToForgetWeights);
88  CheckConstTensorPtrs("InputToCellWeights", m_InputParams.m_InputToCellWeights, inputParams.m_InputToCellWeights);
89  CheckConstTensorPtrs(
90  "InputToOutputWeights", m_InputParams.m_InputToOutputWeights, inputParams.m_InputToOutputWeights);
91  CheckConstTensorPtrs(
92  "RecurrentToInputWeights", m_InputParams.m_RecurrentToInputWeights, inputParams.m_RecurrentToInputWeights);
93  CheckConstTensorPtrs(
94  "RecurrentToForgetWeights", m_InputParams.m_RecurrentToForgetWeights, inputParams.m_RecurrentToForgetWeights);
95  CheckConstTensorPtrs(
96  "RecurrentToCellWeights", m_InputParams.m_RecurrentToCellWeights, inputParams.m_RecurrentToCellWeights);
97  CheckConstTensorPtrs(
98  "RecurrentToOutputWeights", m_InputParams.m_RecurrentToOutputWeights, inputParams.m_RecurrentToOutputWeights);
99  CheckConstTensorPtrs(
100  "CellToInputWeights", m_InputParams.m_CellToInputWeights, inputParams.m_CellToInputWeights);
101  CheckConstTensorPtrs(
102  "CellToForgetWeights", m_InputParams.m_CellToForgetWeights, inputParams.m_CellToForgetWeights);
103  CheckConstTensorPtrs(
104  "CellToOutputWeights", m_InputParams.m_CellToOutputWeights, inputParams.m_CellToOutputWeights);
105  CheckConstTensorPtrs("InputGateBias", m_InputParams.m_InputGateBias, inputParams.m_InputGateBias);
106  CheckConstTensorPtrs("ForgetGateBias", m_InputParams.m_ForgetGateBias, inputParams.m_ForgetGateBias);
107  CheckConstTensorPtrs("CellBias", m_InputParams.m_CellBias, inputParams.m_CellBias);
108 }
109 
110 void TestQLstmLayerVisitor::CheckConstTensorPtrs(const std::string& name,
111  const ConstTensor* expected,
112  const ConstTensor* actual)
113 {
114  if (expected == nullptr)
115  {
116  BOOST_CHECK_MESSAGE(actual == nullptr, name + " actual should have been a nullptr");
117  }
118  else
119  {
120  BOOST_CHECK_MESSAGE(actual != nullptr, name + " actual should have been set");
121  if (actual != nullptr)
122  {
123  CheckConstTensors(*expected, *actual);
124  }
125  }
126 }
127 
128 void TestQLstmLayerVisitor::CheckDescriptor(const QLstmDescriptor& descriptor)
129 {
130  BOOST_CHECK(m_Descriptor.m_CellClip == descriptor.m_CellClip);
131  BOOST_CHECK(m_Descriptor.m_ProjectionClip == descriptor.m_ProjectionClip);
132  BOOST_CHECK(m_Descriptor.m_CifgEnabled == descriptor.m_CifgEnabled);
133  BOOST_CHECK(m_Descriptor.m_PeepholeEnabled == descriptor.m_PeepholeEnabled);
134  BOOST_CHECK(m_Descriptor.m_ProjectionEnabled == descriptor.m_ProjectionEnabled);
135 }
136 
137 void TestQLstmLayerVisitor::CheckInputParameters(const LstmInputParams& inputParams)
138 {
139  CheckConstTensorPtrs("InputToInputWeights",
140  m_InputParams.m_InputToInputWeights,
141  inputParams.m_InputToInputWeights);
142 
143  CheckConstTensorPtrs("InputToForgetWeights",
144  m_InputParams.m_InputToForgetWeights,
145  inputParams.m_InputToForgetWeights);
146 
147  CheckConstTensorPtrs("InputToCellWeights",
148  m_InputParams.m_InputToCellWeights,
149  inputParams.m_InputToCellWeights);
150 
151  CheckConstTensorPtrs("InputToOutputWeights",
152  m_InputParams.m_InputToOutputWeights,
153  inputParams.m_InputToOutputWeights);
154 
155  CheckConstTensorPtrs("RecurrentToInputWeights",
156  m_InputParams.m_RecurrentToInputWeights,
157  inputParams.m_RecurrentToInputWeights);
158 
159  CheckConstTensorPtrs("RecurrentToForgetWeights",
160  m_InputParams.m_RecurrentToForgetWeights,
161  inputParams.m_RecurrentToForgetWeights);
162 
163  CheckConstTensorPtrs("RecurrentToCellWeights",
164  m_InputParams.m_RecurrentToCellWeights,
165  inputParams.m_RecurrentToCellWeights);
166 
167  CheckConstTensorPtrs("RecurrentToOutputWeights",
168  m_InputParams.m_RecurrentToOutputWeights,
169  inputParams.m_RecurrentToOutputWeights);
170 
171  CheckConstTensorPtrs("CellToInputWeights",
172  m_InputParams.m_CellToInputWeights,
173  inputParams.m_CellToInputWeights);
174 
175  CheckConstTensorPtrs("CellToForgetWeights",
176  m_InputParams.m_CellToForgetWeights,
177  inputParams.m_CellToForgetWeights);
178 
179  CheckConstTensorPtrs("CellToOutputWeights",
180  m_InputParams.m_CellToOutputWeights,
181  inputParams.m_CellToOutputWeights);
182 
183  CheckConstTensorPtrs("ProjectionWeights", m_InputParams.m_ProjectionWeights, inputParams.m_ProjectionWeights);
184  CheckConstTensorPtrs("ProjectionBias", m_InputParams.m_ProjectionBias, inputParams.m_ProjectionBias);
185 
186  CheckConstTensorPtrs("InputGateBias", m_InputParams.m_InputGateBias, inputParams.m_InputGateBias);
187  CheckConstTensorPtrs("ForgetGateBias", m_InputParams.m_ForgetGateBias, inputParams.m_ForgetGateBias);
188  CheckConstTensorPtrs("CellBias", m_InputParams.m_CellBias, inputParams.m_CellBias);
189  CheckConstTensorPtrs("OutputGateBias", m_InputParams.m_OutputGateBias, inputParams.m_OutputGateBias);
190 
191  CheckConstTensorPtrs("InputLayerNormWeights",
192  m_InputParams.m_InputLayerNormWeights,
193  inputParams.m_InputLayerNormWeights);
194 
195  CheckConstTensorPtrs("ForgetLayerNormWeights",
196  m_InputParams.m_ForgetLayerNormWeights,
197  inputParams.m_ForgetLayerNormWeights);
198 
199  CheckConstTensorPtrs("CellLayerNormWeights",
200  m_InputParams.m_CellLayerNormWeights,
201  inputParams.m_CellLayerNormWeights);
202 
203  CheckConstTensorPtrs("OutputLayerNormWeights",
204  m_InputParams.m_OutputLayerNormWeights,
205  inputParams.m_OutputLayerNormWeights);
206 }
207 
208 void TestQuantizedLstmLayerVisitor::CheckConstTensorPtrs(const std::string& name,
209  const ConstTensor* expected,
210  const ConstTensor* actual)
211 {
212  if (expected == nullptr)
213  {
214  BOOST_CHECK_MESSAGE(actual == nullptr, name + " actual should have been a nullptr");
215  }
216  else
217  {
218  BOOST_CHECK_MESSAGE(actual != nullptr, name + " actual should have been set");
219  if (actual != nullptr)
220  {
221  CheckConstTensors(*expected, *actual);
222  }
223  }
224 }
225 
226 void TestQuantizedLstmLayerVisitor::CheckInputParameters(const QuantizedLstmInputParams& inputParams)
227 {
228  CheckConstTensorPtrs("InputToInputWeights",
229  m_InputParams.m_InputToInputWeights,
230  inputParams.m_InputToInputWeights);
231 
232  CheckConstTensorPtrs("InputToForgetWeights",
233  m_InputParams.m_InputToForgetWeights,
234  inputParams.m_InputToForgetWeights);
235 
236  CheckConstTensorPtrs("InputToCellWeights",
237  m_InputParams.m_InputToCellWeights,
238  inputParams.m_InputToCellWeights);
239 
240  CheckConstTensorPtrs("InputToOutputWeights",
241  m_InputParams.m_InputToOutputWeights,
242  inputParams.m_InputToOutputWeights);
243 
244  CheckConstTensorPtrs("RecurrentToInputWeights",
245  m_InputParams.m_RecurrentToInputWeights,
246  inputParams.m_RecurrentToInputWeights);
247 
248  CheckConstTensorPtrs("RecurrentToForgetWeights",
249  m_InputParams.m_RecurrentToForgetWeights,
250  inputParams.m_RecurrentToForgetWeights);
251 
252  CheckConstTensorPtrs("RecurrentToCellWeights",
253  m_InputParams.m_RecurrentToCellWeights,
254  inputParams.m_RecurrentToCellWeights);
255 
256  CheckConstTensorPtrs("RecurrentToOutputWeights",
257  m_InputParams.m_RecurrentToOutputWeights,
258  inputParams.m_RecurrentToOutputWeights);
259 
260  CheckConstTensorPtrs("InputGateBias", m_InputParams.m_InputGateBias, inputParams.m_InputGateBias);
261  CheckConstTensorPtrs("ForgetGateBias", m_InputParams.m_ForgetGateBias, inputParams.m_ForgetGateBias);
262  CheckConstTensorPtrs("CellBias", m_InputParams.m_CellBias, inputParams.m_CellBias);
263  CheckConstTensorPtrs("OutputGateBias", m_InputParams.m_OutputGateBias, inputParams.m_OutputGateBias);
264 }
265 
266 BOOST_AUTO_TEST_SUITE(TestConstTensorLayerVisitor)
267 
268 BOOST_AUTO_TEST_CASE(CheckConvolution2dLayer)
269 {
270  Convolution2dDescriptor descriptor;
271  descriptor.m_PadLeft = 2;
272  descriptor.m_PadRight = 3;
273  descriptor.m_PadBottom = 1;
274  descriptor.m_PadTop = 5;
275  descriptor.m_StrideX = 2;
276  descriptor.m_StrideY = 3;
277  descriptor.m_DataLayout = DataLayout::NHWC;
278 
279  std::vector<float> data = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
280  std::vector<unsigned int> dimensions = {1, 1, 3, 3};
281  ConstTensor weights(TensorInfo(4, dimensions.data(), DataType::Float32), data);
282 
283  TestConvolution2dLayerVisitor visitor(descriptor, weights, EmptyOptional());
284 
285  NetworkImpl net;
286 
287  IConnectableLayer* const layer = net.AddConvolution2dLayer(descriptor, weights, EmptyOptional());
288  layer->Accept(visitor);
289 }
290 
291 BOOST_AUTO_TEST_CASE(CheckNamedConvolution2dLayer)
292 {
293  const char* layerName = "Convolution2dLayer";
294  Convolution2dDescriptor descriptor;
295  descriptor.m_PadLeft = 2;
296  descriptor.m_PadRight = 3;
297  descriptor.m_PadBottom = 1;
298  descriptor.m_PadTop = 5;
299  descriptor.m_StrideX = 2;
300  descriptor.m_StrideY = 3;
301  descriptor.m_DataLayout = DataLayout::NHWC;
302 
303  std::vector<float> data = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
304  std::vector<unsigned int> dimensions = {1, 1, 3, 3};
305  ConstTensor weights(TensorInfo(4, dimensions.data(), DataType::Float32), data);
306 
307  TestConvolution2dLayerVisitor visitor(descriptor, weights, EmptyOptional(), layerName);
308 
309  NetworkImpl net;
310 
311  IConnectableLayer* const layer = net.AddConvolution2dLayer(descriptor, weights, EmptyOptional(), layerName);
312  layer->Accept(visitor);
313 }
314 
315 BOOST_AUTO_TEST_CASE(CheckConvolution2dLayerWithBiases)
316 {
317  Convolution2dDescriptor descriptor;
318  descriptor.m_PadLeft = 2;
319  descriptor.m_PadRight = 3;
320  descriptor.m_PadBottom = 1;
321  descriptor.m_PadTop = 5;
322  descriptor.m_StrideX = 2;
323  descriptor.m_StrideY = 3;
324  descriptor.m_DataLayout = DataLayout::NHWC;
325  descriptor.m_BiasEnabled = true;
326 
327  std::vector<float> data = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
328  std::vector<unsigned int> dimensions = {1, 1, 3, 3};
329  ConstTensor weights(TensorInfo(4, dimensions.data(), DataType::Float32), data);
330 
331  std::vector<float> biasData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
332  std::vector<unsigned int> biasDimensions = {1, 1, 3, 3};
333  ConstTensor biases(TensorInfo(4, biasDimensions.data(), DataType::Float32), biasData);
334  Optional<ConstTensor> optionalBiases(biases);
335 
336  TestConvolution2dLayerVisitor visitor(descriptor, weights, optionalBiases);
337 
338  NetworkImpl net;
339 
340  IConnectableLayer* const layer = net.AddConvolution2dLayer(descriptor, weights, optionalBiases);
341  layer->Accept(visitor);
342 }
343 
344 BOOST_AUTO_TEST_CASE(CheckNamedConvolution2dLayerWithBiases)
345 {
346  const char* layerName = "Convolution2dLayer";
347  Convolution2dDescriptor descriptor;
348  descriptor.m_PadLeft = 2;
349  descriptor.m_PadRight = 3;
350  descriptor.m_PadBottom = 1;
351  descriptor.m_PadTop = 5;
352  descriptor.m_StrideX = 2;
353  descriptor.m_StrideY = 3;
354  descriptor.m_DataLayout = DataLayout::NHWC;
355  descriptor.m_BiasEnabled = true;
356 
357  std::vector<float> data = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
358  std::vector<unsigned int> dimensions = {1, 1, 3, 3};
359  ConstTensor weights(TensorInfo(4, dimensions.data(), DataType::Float32), data);
360 
361  std::vector<float> biasData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
362  std::vector<unsigned int> biasDimensions = {1, 1, 3, 3};
363  ConstTensor biases(TensorInfo(4, biasDimensions.data(), DataType::Float32), biasData);
364  Optional<ConstTensor> optionalBiases(biases);
365 
366  TestConvolution2dLayerVisitor visitor(descriptor, weights, optionalBiases, layerName);
367 
368  NetworkImpl net;
369 
370  IConnectableLayer* const layer = net.AddConvolution2dLayer(descriptor, weights, optionalBiases, layerName);
371  layer->Accept(visitor);
372 }
373 
374 BOOST_AUTO_TEST_CASE(CheckDepthwiseConvolution2dLayer)
375 {
376  DepthwiseConvolution2dDescriptor descriptor;
377  descriptor.m_PadLeft = 2;
378  descriptor.m_PadRight = 3;
379  descriptor.m_PadBottom = 1;
380  descriptor.m_PadTop = 5;
381  descriptor.m_StrideX = 2;
382  descriptor.m_StrideY = 3;
383  descriptor.m_DataLayout = DataLayout::NHWC;
384 
385  std::vector<float> data = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
386  std::vector<unsigned int> dimensions = {1, 1, 3, 3};
387  ConstTensor weights(TensorInfo(4, dimensions.data(), DataType::Float32), data);
388 
389  TestDepthwiseConvolution2dLayerVisitor visitor(descriptor, weights, EmptyOptional());
390 
391  NetworkImpl net;
392 
393  IConnectableLayer* const layer = net.AddDepthwiseConvolution2dLayer(descriptor, weights, EmptyOptional());
394  layer->Accept(visitor);
395 }
396 
397 BOOST_AUTO_TEST_CASE(CheckNamedDepthwiseConvolution2dLayer)
398 {
399  const char* layerName = "DepthwiseConvolution2dLayer";
400  DepthwiseConvolution2dDescriptor descriptor;
401  descriptor.m_PadLeft = 2;
402  descriptor.m_PadRight = 3;
403  descriptor.m_PadBottom = 1;
404  descriptor.m_PadTop = 5;
405  descriptor.m_StrideX = 2;
406  descriptor.m_StrideY = 3;
407  descriptor.m_DataLayout = DataLayout::NHWC;
408 
409  std::vector<float> data = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
410  std::vector<unsigned int> dimensions = {1, 1, 3, 3};
411  ConstTensor weights(TensorInfo(4, dimensions.data(), DataType::Float32), data);
412 
413  TestDepthwiseConvolution2dLayerVisitor visitor(descriptor, weights, EmptyOptional(), layerName);
414 
415  NetworkImpl net;
416 
417  IConnectableLayer* const layer = net.AddDepthwiseConvolution2dLayer(descriptor,
418  weights,
419  EmptyOptional(),
420  layerName);
421  layer->Accept(visitor);
422 }
423 
424 BOOST_AUTO_TEST_CASE(CheckDepthwiseConvolution2dLayerWithBiases)
425 {
426  DepthwiseConvolution2dDescriptor descriptor;
427  descriptor.m_PadLeft = 2;
428  descriptor.m_PadRight = 3;
429  descriptor.m_PadBottom = 1;
430  descriptor.m_PadTop = 5;
431  descriptor.m_StrideX = 2;
432  descriptor.m_StrideY = 3;
433  descriptor.m_DataLayout = DataLayout::NHWC;
434  descriptor.m_BiasEnabled = true;
435 
436  std::vector<float> data = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
437  std::vector<unsigned int> dimensions = {1, 1, 3, 3};
438  ConstTensor weights(TensorInfo(4, dimensions.data(), DataType::Float32), data);
439 
440  std::vector<float> biasData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
441  std::vector<unsigned int> biasDimensions = {1, 1, 3, 3};
442  ConstTensor biases(TensorInfo(4, biasDimensions.data(), DataType::Float32), biasData);
443  Optional<ConstTensor> optionalBiases(biases);
444 
445  TestDepthwiseConvolution2dLayerVisitor visitor(descriptor, weights, optionalBiases);
446 
447  NetworkImpl net;
448 
449  IConnectableLayer* const layer = net.AddDepthwiseConvolution2dLayer(descriptor, weights, optionalBiases);
450  layer->Accept(visitor);
451 }
452 
453 BOOST_AUTO_TEST_CASE(CheckNamedDepthwiseConvolution2dLayerWithBiases)
454 {
455  const char* layerName = "DepthwiseConvolution2dLayer";
456  DepthwiseConvolution2dDescriptor descriptor;
457  descriptor.m_PadLeft = 2;
458  descriptor.m_PadRight = 3;
459  descriptor.m_PadBottom = 1;
460  descriptor.m_PadTop = 5;
461  descriptor.m_StrideX = 2;
462  descriptor.m_StrideY = 3;
463  descriptor.m_DataLayout = DataLayout::NHWC;
464  descriptor.m_BiasEnabled = true;
465 
466  std::vector<float> data = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
467  std::vector<unsigned int> dimensions = {1, 1, 3, 3};
468  ConstTensor weights(TensorInfo(4, dimensions.data(), DataType::Float32), data);
469 
470  std::vector<float> biasData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
471  std::vector<unsigned int> biasDimensions = {1, 1, 3, 3};
472  ConstTensor biases(TensorInfo(4, biasDimensions.data(), DataType::Float32), biasData);
473  Optional<ConstTensor> optionalBiases(biases);
474 
475  TestDepthwiseConvolution2dLayerVisitor visitor(descriptor, weights, optionalBiases, layerName);
476 
477  NetworkImpl net;
478 
479  IConnectableLayer* const layer = net.AddDepthwiseConvolution2dLayer(descriptor, weights, optionalBiases, layerName);
480  layer->Accept(visitor);
481 }
482 
483 BOOST_AUTO_TEST_CASE(CheckFullyConnectedLayer)
484 {
485  FullyConnectedDescriptor descriptor;
486  descriptor.m_TransposeWeightMatrix = true;
487 
488  std::vector<float> data = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
489  std::vector<unsigned int> dimensions = {1, 1, 3, 3};
490  ConstTensor weights(TensorInfo(4, dimensions.data(), DataType::Float32), data);
491 
492  TestFullyConnectedLayerVistor visitor(descriptor, weights, EmptyOptional());
493 
494  NetworkImpl net;
495 
496  IConnectableLayer* const layer = net.AddFullyConnectedLayer(descriptor, weights, EmptyOptional());
497  layer->Accept(visitor);
498 }
499 
500 BOOST_AUTO_TEST_CASE(CheckNamedFullyConnectedLayer)
501 {
502  const char* layerName = "FullyConnectedLayer";
503  FullyConnectedDescriptor descriptor;
504  descriptor.m_TransposeWeightMatrix = true;
505 
506  std::vector<float> data = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
507  std::vector<unsigned int> dimensions = {1, 1, 3, 3};
508  ConstTensor weights(TensorInfo(4, dimensions.data(), DataType::Float32), data);
509 
510  TestFullyConnectedLayerVistor visitor(descriptor, weights, EmptyOptional(), layerName);
511 
512  NetworkImpl net;
513 
514  IConnectableLayer* const layer = net.AddFullyConnectedLayer(descriptor, weights, EmptyOptional(), layerName);
515  layer->Accept(visitor);
516 }
517 
518 BOOST_AUTO_TEST_CASE(CheckFullyConnectedLayerWithBiases)
519 {
520  FullyConnectedDescriptor descriptor;
521  descriptor.m_TransposeWeightMatrix = true;
522  descriptor.m_BiasEnabled = true;
523 
524  std::vector<float> data = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
525  std::vector<unsigned int> dimensions = {1, 1, 3, 3};
526  ConstTensor weights(TensorInfo(4, dimensions.data(), DataType::Float32), data);
527 
528  std::vector<float> biasData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
529  std::vector<unsigned int> biasDimensions = {1, 1, 3, 3};
530  ConstTensor biases(TensorInfo(4, biasDimensions.data(), DataType::Float32), biasData);
531  Optional<ConstTensor> optionalBiases(biases);
532 
533  TestFullyConnectedLayerVistor visitor(descriptor, weights, optionalBiases);
534 
535  NetworkImpl net;
536 
537  IConnectableLayer* const layer = net.AddFullyConnectedLayer(descriptor, weights, optionalBiases);
538  layer->Accept(visitor);
539 }
540 
541 BOOST_AUTO_TEST_CASE(CheckNamedFullyConnectedLayerWithBiases)
542 {
543  const char* layerName = "FullyConnectedLayer";
544  FullyConnectedDescriptor descriptor;
545  descriptor.m_TransposeWeightMatrix = true;
546  descriptor.m_BiasEnabled = true;
547 
548  std::vector<float> data = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
549  std::vector<unsigned int> dimensions = {1, 1, 3, 3};
550  ConstTensor weights(TensorInfo(4, dimensions.data(), DataType::Float32), data);
551 
552  std::vector<float> biasData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
553  std::vector<unsigned int> biasDimensions = {1, 1, 3, 3};
554  ConstTensor biases(TensorInfo(4, biasDimensions.data(), DataType::Float32), biasData);
555  Optional<ConstTensor> optionalBiases(biases);
556 
557  TestFullyConnectedLayerVistor visitor(descriptor, weights, optionalBiases, layerName);
558 
559  NetworkImpl net;
560 
561  IConnectableLayer* const layer = net.AddFullyConnectedLayer(descriptor, weights, optionalBiases, layerName);
562  layer->Accept(visitor);
563 }
564 
565 BOOST_AUTO_TEST_CASE(CheckBatchNormalizationLayer)
566 {
567  BatchNormalizationDescriptor descriptor;
568  descriptor.m_Eps = 0.0002f;
569  descriptor.m_DataLayout = DataLayout::NHWC;
570 
571  std::vector<float> data = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
572  std::vector<unsigned int> dimensions = {1, 1, 3, 3};
573  ConstTensor mean(TensorInfo(4, dimensions.data(), DataType::Float32), data);
574 
575  std::vector<float> varianceData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
576  std::vector<unsigned int> varianceDimensions = {1, 1, 3, 3};
577  ConstTensor variance(TensorInfo(4, varianceDimensions.data(), DataType::Float32), varianceData);
578 
579  std::vector<float> betaData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
580  std::vector<unsigned int> betaDimensions = {1, 1, 3, 3};
581  ConstTensor beta(TensorInfo(4, betaDimensions.data(), DataType::Float32), betaData);
582 
583  std::vector<float> gammaData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
584  std::vector<unsigned int> gammaDimensions = {1, 1, 3, 3};
585  ConstTensor gamma(TensorInfo(4, gammaDimensions.data(), DataType::Float32), gammaData);
586 
587  TestBatchNormalizationLayerVisitor visitor(descriptor, mean, variance, beta, gamma);
588 
589  NetworkImpl net;
590 
591  IConnectableLayer* const layer = net.AddBatchNormalizationLayer(descriptor, mean, variance, beta, gamma);
592  layer->Accept(visitor);
593 }
594 
595 BOOST_AUTO_TEST_CASE(CheckNamedBatchNormalizationLayer)
596 {
597  const char* layerName = "BatchNormalizationLayer";
598  BatchNormalizationDescriptor descriptor;
599  descriptor.m_Eps = 0.0002f;
600  descriptor.m_DataLayout = DataLayout::NHWC;
601 
602  std::vector<float> data = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
603  std::vector<unsigned int> dimensions = {1, 1, 3, 3};
604  ConstTensor mean(TensorInfo(4, dimensions.data(), DataType::Float32), data);
605 
606  std::vector<float> varianceData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
607  std::vector<unsigned int> varianceDimensions = {1, 1, 3, 3};
608  ConstTensor variance(TensorInfo(4, varianceDimensions.data(), DataType::Float32), varianceData);
609 
610  std::vector<float> betaData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
611  std::vector<unsigned int> betaDimensions = {1, 1, 3, 3};
612  ConstTensor beta(TensorInfo(4, betaDimensions.data(), DataType::Float32), betaData);
613 
614  std::vector<float> gammaData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
615  std::vector<unsigned int> gammaDimensions = {1, 1, 3, 3};
616  ConstTensor gamma(TensorInfo(4, gammaDimensions.data(), DataType::Float32), gammaData);
617 
618  TestBatchNormalizationLayerVisitor visitor(descriptor, mean, variance, beta, gamma, layerName);
619 
620  NetworkImpl net;
621 
622  IConnectableLayer* const layer = net.AddBatchNormalizationLayer(
623  descriptor, mean, variance, beta, gamma, layerName);
624  layer->Accept(visitor);
625 }
626 
627 BOOST_AUTO_TEST_CASE(CheckConstLayer)
628 {
629  std::vector<float> data = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
630  std::vector<unsigned int> dimensions = {1, 1, 3, 3};
631  ConstTensor input(TensorInfo(4, dimensions.data(), DataType::Float32), data);
632 
633  TestConstantLayerVisitor visitor(input);
634 
635  NetworkImpl net;
636 
637  IConnectableLayer* const layer = net.AddConstantLayer(input);
638  layer->Accept(visitor);
639 }
640 
641 BOOST_AUTO_TEST_CASE(CheckNamedConstLayer)
642 {
643  const char* layerName = "ConstantLayer";
644  std::vector<float> data = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
645  std::vector<unsigned int> dimensions = {1, 1, 3, 3};
646  ConstTensor input(TensorInfo(4, dimensions.data(), DataType::Float32), data);
647 
648  TestConstantLayerVisitor visitor(input, layerName);
649 
650  NetworkImpl net;
651 
652  IConnectableLayer* const layer = net.AddConstantLayer(input, layerName);
653  layer->Accept(visitor);
654 }
655 
656 BOOST_AUTO_TEST_CASE(CheckLstmLayerBasic)
657 {
658  LstmDescriptor descriptor;
659  descriptor.m_ActivationFunc = 3;
660  descriptor.m_ClippingThresProj = 0.5f;
661  descriptor.m_ClippingThresCell = 0.3f;
662  descriptor.m_CifgEnabled = true; // if this is true then we DON'T need to set the OptCifgParams
663 
664  std::vector<float> inputToForgetWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
665  std::vector<unsigned int> inputToForgetWeightsDimensions = {1, 1, 3, 3};
666  ConstTensor inputToForgetWeights(
667  TensorInfo(4, inputToForgetWeightsDimensions.data(), DataType::Float32), inputToForgetWeightsData);
668 
669  std::vector<float> inputToCellWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
670  std::vector<unsigned int> inputToCellWeightsDimensions = {1, 1, 3, 3};
671  ConstTensor inputToCellWeights(
672  TensorInfo(4, inputToCellWeightsDimensions.data(), DataType::Float32), inputToCellWeightsData);
673 
674  std::vector<float> inputToOutputWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
675  std::vector<unsigned int> inputToOutputWeightsDimensions = {1, 1, 3, 3};
676  ConstTensor inputToOutputWeights(
677  TensorInfo(4, inputToOutputWeightsDimensions.data(), DataType::Float32), inputToOutputWeightsData);
678 
679  std::vector<float> recurrentToForgetWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
680  std::vector<unsigned int> recurrentToForgetWeightsDimensions = {1, 1, 3, 3};
681  ConstTensor recurrentToForgetWeights(TensorInfo(
682  4, recurrentToForgetWeightsDimensions.data(), DataType::Float32), recurrentToForgetWeightsData);
683 
684  std::vector<float> recurrentToCellWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
685  std::vector<unsigned int> recurrentToCellWeightsDimensions = {1, 1, 3, 3};
686  ConstTensor recurrentToCellWeights(TensorInfo(
687  4, recurrentToCellWeightsDimensions.data(), DataType::Float32), recurrentToCellWeightsData);
688 
689  std::vector<float> recurrentToOutputWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
690  std::vector<unsigned int> recurrentToOutputWeightsDimensions = {1, 1, 3, 3};
691  ConstTensor recurrentToOutputWeights(TensorInfo(
692  4, recurrentToOutputWeightsDimensions.data(), DataType::Float32), recurrentToOutputWeightsData);
693 
694  std::vector<float> forgetGateBiasData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
695  std::vector<unsigned int> forgetGateBiasDimensions = {1, 1, 3, 3};
696  ConstTensor forgetGateBias(TensorInfo(
697  4, forgetGateBiasDimensions.data(), DataType::Float32), forgetGateBiasData);
698 
699  std::vector<float> cellBiasData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
700  std::vector<unsigned int> cellBiasDimensions = {1, 1, 3, 3};
701  ConstTensor cellBias(TensorInfo(
702  4, cellBiasDimensions.data(), DataType::Float32), cellBiasData);
703 
704  std::vector<float> outputGateBiasData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
705  std::vector<unsigned int> outputGateBiasDimensions = {1, 1, 3, 3};
706  ConstTensor outputGateBias(TensorInfo(
707  4, outputGateBiasDimensions.data(), DataType::Float32), outputGateBiasData);
708 
709  LstmInputParams params;
710  params.m_InputToForgetWeights = &inputToForgetWeights;
711  params.m_InputToCellWeights = &inputToCellWeights;
712  params.m_InputToOutputWeights = &inputToOutputWeights;
713  params.m_RecurrentToForgetWeights = &recurrentToForgetWeights;
714  params.m_RecurrentToCellWeights = &recurrentToCellWeights;
715  params.m_RecurrentToOutputWeights = &recurrentToOutputWeights;
716  params.m_ForgetGateBias = &forgetGateBias;
717  params.m_CellBias = &cellBias;
718  params.m_OutputGateBias = &outputGateBias;
719 
720  TestLstmLayerVisitor visitor(descriptor, params);
721 
722  NetworkImpl net;
723 
724  IConnectableLayer* const layer = net.AddLstmLayer(descriptor, params);
725  layer->Accept(visitor);
726 }
727 
728 BOOST_AUTO_TEST_CASE(CheckNamedLstmLayerBasic)
729 {
730  const char* layerName = "LstmLayer";
731  LstmDescriptor descriptor;
732  descriptor.m_ActivationFunc = 3;
733  descriptor.m_ClippingThresProj = 0.5f;
734  descriptor.m_ClippingThresCell = 0.3f;
735  descriptor.m_CifgEnabled = true; // if this is true then we DON'T need to set the OptCifgParams
736 
737  std::vector<float> inputToForgetWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
738  std::vector<unsigned int> inputToForgetWeightsDimensions = {1, 1, 3, 3};
739  ConstTensor inputToForgetWeights(
740  TensorInfo(4, inputToForgetWeightsDimensions.data(), DataType::Float32), inputToForgetWeightsData);
741 
742  std::vector<float> inputToCellWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
743  std::vector<unsigned int> inputToCellWeightsDimensions = {1, 1, 3, 3};
744  ConstTensor inputToCellWeights(
745  TensorInfo(4, inputToCellWeightsDimensions.data(), DataType::Float32), inputToCellWeightsData);
746 
747  std::vector<float> inputToOutputWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
748  std::vector<unsigned int> inputToOutputWeightsDimensions = {1, 1, 3, 3};
749  ConstTensor inputToOutputWeights(
750  TensorInfo(4, inputToOutputWeightsDimensions.data(), DataType::Float32), inputToOutputWeightsData);
751 
752  std::vector<float> recurrentToForgetWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
753  std::vector<unsigned int> recurrentToForgetWeightsDimensions = {1, 1, 3, 3};
754  ConstTensor recurrentToForgetWeights(TensorInfo(
755  4, recurrentToForgetWeightsDimensions.data(), DataType::Float32), recurrentToForgetWeightsData);
756 
757  std::vector<float> recurrentToCellWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
758  std::vector<unsigned int> recurrentToCellWeightsDimensions = {1, 1, 3, 3};
759  ConstTensor recurrentToCellWeights(TensorInfo(
760  4, recurrentToCellWeightsDimensions.data(), DataType::Float32), recurrentToCellWeightsData);
761 
762  std::vector<float> recurrentToOutputWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
763  std::vector<unsigned int> recurrentToOutputWeightsDimensions = {1, 1, 3, 3};
764  ConstTensor recurrentToOutputWeights(TensorInfo(
765  4, recurrentToOutputWeightsDimensions.data(), DataType::Float32), recurrentToOutputWeightsData);
766 
767  std::vector<float> forgetGateBiasData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
768  std::vector<unsigned int> forgetGateBiasDimensions = {1, 1, 3, 3};
769  ConstTensor forgetGateBias(TensorInfo(
770  4, forgetGateBiasDimensions.data(), DataType::Float32), forgetGateBiasData);
771 
772  std::vector<float> cellBiasData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
773  std::vector<unsigned int> cellBiasDimensions = {1, 1, 3, 3};
774  ConstTensor cellBias(TensorInfo(
775  4, cellBiasDimensions.data(), DataType::Float32), cellBiasData);
776 
777  std::vector<float> outputGateBiasData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
778  std::vector<unsigned int> outputGateBiasDimensions = {1, 1, 3, 3};
779  ConstTensor outputGateBias(TensorInfo(
780  4, outputGateBiasDimensions.data(), DataType::Float32), outputGateBiasData);
781 
782  LstmInputParams params;
783  params.m_InputToForgetWeights = &inputToForgetWeights;
784  params.m_InputToCellWeights = &inputToCellWeights;
785  params.m_InputToOutputWeights = &inputToOutputWeights;
786  params.m_RecurrentToForgetWeights = &recurrentToForgetWeights;
787  params.m_RecurrentToCellWeights = &recurrentToCellWeights;
788  params.m_RecurrentToOutputWeights = &recurrentToOutputWeights;
789  params.m_ForgetGateBias = &forgetGateBias;
790  params.m_CellBias = &cellBias;
791  params.m_OutputGateBias = &outputGateBias;
792 
793  TestLstmLayerVisitor visitor(descriptor, params, layerName);
794 
795  NetworkImpl net;
796 
797  IConnectableLayer* const layer = net.AddLstmLayer(descriptor, params, layerName);
798  layer->Accept(visitor);
799 }
800 
801 BOOST_AUTO_TEST_CASE(CheckLstmLayerCifgDisabled)
802 {
803  LstmDescriptor descriptor;
804  descriptor.m_ActivationFunc = 3;
805  descriptor.m_ClippingThresProj = 0.5f;
806  descriptor.m_ClippingThresCell = 0.3f;
807  descriptor.m_CifgEnabled = false; // if this is true then we DON'T need to set the OptCifgParams
808 
809  std::vector<float> inputToForgetWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
810  std::vector<unsigned int> inputToForgetWeightsDimensions = {1, 1, 3, 3};
811  ConstTensor inputToForgetWeights(
812  TensorInfo(4, inputToForgetWeightsDimensions.data(), DataType::Float32), inputToForgetWeightsData);
813 
814  std::vector<float> inputToCellWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
815  std::vector<unsigned int> inputToCellWeightsDimensions = {1, 1, 3, 3};
816  ConstTensor inputToCellWeights(
817  TensorInfo(4, inputToCellWeightsDimensions.data(), DataType::Float32), inputToCellWeightsData);
818 
819  std::vector<float> inputToOutputWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
820  std::vector<unsigned int> inputToOutputWeightsDimensions = {1, 1, 3, 3};
821  ConstTensor inputToOutputWeights(
822  TensorInfo(4, inputToOutputWeightsDimensions.data(), DataType::Float32), inputToOutputWeightsData);
823 
824  std::vector<float> recurrentToForgetWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
825  std::vector<unsigned int> recurrentToForgetWeightsDimensions = {1, 1, 3, 3};
826  ConstTensor recurrentToForgetWeights(TensorInfo(
827  4, recurrentToForgetWeightsDimensions.data(), DataType::Float32), recurrentToForgetWeightsData);
828 
829  std::vector<float> recurrentToCellWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
830  std::vector<unsigned int> recurrentToCellWeightsDimensions = {1, 1, 3, 3};
831  ConstTensor recurrentToCellWeights(TensorInfo(
832  4, recurrentToCellWeightsDimensions.data(), DataType::Float32), recurrentToCellWeightsData);
833 
834  std::vector<float> recurrentToOutputWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
835  std::vector<unsigned int> recurrentToOutputWeightsDimensions = {1, 1, 3, 3};
836  ConstTensor recurrentToOutputWeights(TensorInfo(
837  4, recurrentToOutputWeightsDimensions.data(), DataType::Float32), recurrentToOutputWeightsData);
838 
839  std::vector<float> forgetGateBiasData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
840  std::vector<unsigned int> forgetGateBiasDimensions = {1, 1, 3, 3};
841  ConstTensor forgetGateBias(TensorInfo(
842  4, forgetGateBiasDimensions.data(), DataType::Float32), forgetGateBiasData);
843 
844  std::vector<float> cellBiasData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
845  std::vector<unsigned int> cellBiasDimensions = {1, 1, 3, 3};
846  ConstTensor cellBias(TensorInfo(
847  4, cellBiasDimensions.data(), DataType::Float32), cellBiasData);
848 
849  std::vector<float> outputGateBiasData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
850  std::vector<unsigned int> outputGateBiasDimensions = {1, 1, 3, 3};
851  ConstTensor outputGateBias(TensorInfo(
852  4, outputGateBiasDimensions.data(), DataType::Float32), outputGateBiasData);
853 
854  std::vector<float> inputToInputWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
855  std::vector<unsigned int> inputToInputWeightsDimensions = {1, 1, 3, 3};
856  ConstTensor inputToInputWeights(
857  TensorInfo(4, inputToInputWeightsDimensions.data(), DataType::Float32), inputToInputWeightsData);
858 
859  std::vector<float> recurrentToInputWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
860  std::vector<unsigned int> recurrentToInputWeightsDimensions = {1, 1, 3, 3};
861  ConstTensor recurrentToInputWeights(TensorInfo(
862  4, recurrentToInputWeightsDimensions.data(), DataType::Float32), recurrentToInputWeightsData);
863 
864  std::vector<float> inputGateBiasData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
865  std::vector<unsigned int> inputGateBiasDimensions = {1, 1, 3, 3};
866  ConstTensor inputGateBias(
867  TensorInfo(4, inputGateBiasDimensions.data(), DataType::Float32), inputGateBiasData);
868 
869  LstmInputParams params;
870  params.m_InputToForgetWeights = &inputToForgetWeights;
871  params.m_InputToCellWeights = &inputToCellWeights;
872  params.m_InputToOutputWeights = &inputToOutputWeights;
873  params.m_RecurrentToForgetWeights = &recurrentToForgetWeights;
874  params.m_RecurrentToCellWeights = &recurrentToCellWeights;
875  params.m_RecurrentToOutputWeights = &recurrentToOutputWeights;
876  params.m_ForgetGateBias = &forgetGateBias;
877  params.m_CellBias = &cellBias;
878  params.m_OutputGateBias = &outputGateBias;
879 
880  params.m_InputToInputWeights = &inputToInputWeights;
881  params.m_RecurrentToInputWeights = &recurrentToInputWeights;
882  params.m_InputGateBias = &inputGateBias;
883 
884  TestLstmLayerVisitor visitor(descriptor, params);
885 
886  NetworkImpl net;
887 
888  IConnectableLayer* const layer = net.AddLstmLayer(descriptor, params);
889  layer->Accept(visitor);
890 }
891 
892 BOOST_AUTO_TEST_CASE(CheckNamedLstmLayerCifgDisabled)
893 {
894  const char* layerName = "LstmLayer";
895  LstmDescriptor descriptor;
896  descriptor.m_ActivationFunc = 3;
897  descriptor.m_ClippingThresProj = 0.5f;
898  descriptor.m_ClippingThresCell = 0.3f;
899  descriptor.m_CifgEnabled = false; // if this is true then we DON'T need to set the OptCifgParams
900 
901  std::vector<float> inputToForgetWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
902  std::vector<unsigned int> inputToForgetWeightsDimensions = {1, 1, 3, 3};
903  ConstTensor inputToForgetWeights(
904  TensorInfo(4, inputToForgetWeightsDimensions.data(), DataType::Float32), inputToForgetWeightsData);
905 
906  std::vector<float> inputToCellWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
907  std::vector<unsigned int> inputToCellWeightsDimensions = {1, 1, 3, 3};
908  ConstTensor inputToCellWeights(
909  TensorInfo(4, inputToCellWeightsDimensions.data(), DataType::Float32), inputToCellWeightsData);
910 
911  std::vector<float> inputToOutputWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
912  std::vector<unsigned int> inputToOutputWeightsDimensions = {1, 1, 3, 3};
913  ConstTensor inputToOutputWeights(
914  TensorInfo(4, inputToOutputWeightsDimensions.data(), DataType::Float32), inputToOutputWeightsData);
915 
916  std::vector<float> recurrentToForgetWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
917  std::vector<unsigned int> recurrentToForgetWeightsDimensions = {1, 1, 3, 3};
918  ConstTensor recurrentToForgetWeights(TensorInfo(
919  4, recurrentToForgetWeightsDimensions.data(), DataType::Float32), recurrentToForgetWeightsData);
920 
921  std::vector<float> recurrentToCellWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
922  std::vector<unsigned int> recurrentToCellWeightsDimensions = {1, 1, 3, 3};
923  ConstTensor recurrentToCellWeights(TensorInfo(
924  4, recurrentToCellWeightsDimensions.data(), DataType::Float32), recurrentToCellWeightsData);
925 
926  std::vector<float> recurrentToOutputWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
927  std::vector<unsigned int> recurrentToOutputWeightsDimensions = {1, 1, 3, 3};
928  ConstTensor recurrentToOutputWeights(TensorInfo(
929  4, recurrentToOutputWeightsDimensions.data(), DataType::Float32), recurrentToOutputWeightsData);
930 
931  std::vector<float> forgetGateBiasData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
932  std::vector<unsigned int> forgetGateBiasDimensions = {1, 1, 3, 3};
933  ConstTensor forgetGateBias(TensorInfo(
934  4, forgetGateBiasDimensions.data(), DataType::Float32), forgetGateBiasData);
935 
936  std::vector<float> cellBiasData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
937  std::vector<unsigned int> cellBiasDimensions = {1, 1, 3, 3};
938  ConstTensor cellBias(TensorInfo(
939  4, cellBiasDimensions.data(), DataType::Float32), cellBiasData);
940 
941  std::vector<float> outputGateBiasData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
942  std::vector<unsigned int> outputGateBiasDimensions = {1, 1, 3, 3};
943  ConstTensor outputGateBias(TensorInfo(
944  4, outputGateBiasDimensions.data(), DataType::Float32), outputGateBiasData);
945 
946  std::vector<float> inputToInputWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
947  std::vector<unsigned int> inputToInputWeightsDimensions = {1, 1, 3, 3};
948  ConstTensor inputToInputWeights(
949  TensorInfo(4, inputToInputWeightsDimensions.data(), DataType::Float32), inputToInputWeightsData);
950 
951  std::vector<float> recurrentToInputWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
952  std::vector<unsigned int> recurrentToInputWeightsDimensions = {1, 1, 3, 3};
953  ConstTensor recurrentToInputWeights(TensorInfo(
954  4, recurrentToInputWeightsDimensions.data(), DataType::Float32), recurrentToInputWeightsData);
955 
956  std::vector<float> inputGateBiasData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
957  std::vector<unsigned int> inputGateBiasDimensions = {1, 1, 3, 3};
958  ConstTensor inputGateBias(
959  TensorInfo(4, inputGateBiasDimensions.data(), DataType::Float32), inputGateBiasData);
960 
961  LstmInputParams params;
962  params.m_InputToForgetWeights = &inputToForgetWeights;
963  params.m_InputToCellWeights = &inputToCellWeights;
964  params.m_InputToOutputWeights = &inputToOutputWeights;
965  params.m_RecurrentToForgetWeights = &recurrentToForgetWeights;
966  params.m_RecurrentToCellWeights = &recurrentToCellWeights;
967  params.m_RecurrentToOutputWeights = &recurrentToOutputWeights;
968  params.m_ForgetGateBias = &forgetGateBias;
969  params.m_CellBias = &cellBias;
970  params.m_OutputGateBias = &outputGateBias;
971 
972  params.m_InputToInputWeights = &inputToInputWeights;
973  params.m_RecurrentToInputWeights = &recurrentToInputWeights;
974  params.m_InputGateBias = &inputGateBias;
975 
976  TestLstmLayerVisitor visitor(descriptor, params, layerName);
977 
978  NetworkImpl net;
979 
980  IConnectableLayer* const layer = net.AddLstmLayer(descriptor, params, layerName);
981  layer->Accept(visitor);
982 }
983 
984 // TODO add one with peephole
985 BOOST_AUTO_TEST_CASE(CheckLstmLayerPeephole)
986 {
987  LstmDescriptor descriptor;
988  descriptor.m_ActivationFunc = 3;
989  descriptor.m_ClippingThresProj = 0.5f;
990  descriptor.m_ClippingThresCell = 0.3f;
991  descriptor.m_CifgEnabled = true; // if this is true then we DON'T need to set the OptCifgParams
992  descriptor.m_PeepholeEnabled = true;
993 
994  std::vector<float> inputToForgetWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
995  std::vector<unsigned int> inputToForgetWeightsDimensions = {1, 1, 3, 3};
996  ConstTensor inputToForgetWeights(
997  TensorInfo(4, inputToForgetWeightsDimensions.data(), DataType::Float32), inputToForgetWeightsData);
998 
999  std::vector<float> inputToCellWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
1000  std::vector<unsigned int> inputToCellWeightsDimensions = {1, 1, 3, 3};
1001  ConstTensor inputToCellWeights(
1002  TensorInfo(4, inputToCellWeightsDimensions.data(), DataType::Float32), inputToCellWeightsData);
1003 
1004  std::vector<float> inputToOutputWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
1005  std::vector<unsigned int> inputToOutputWeightsDimensions = {1, 1, 3, 3};
1006  ConstTensor inputToOutputWeights(
1007  TensorInfo(4, inputToOutputWeightsDimensions.data(), DataType::Float32), inputToOutputWeightsData);
1008 
1009  std::vector<float> recurrentToForgetWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
1010  std::vector<unsigned int> recurrentToForgetWeightsDimensions = {1, 1, 3, 3};
1011  ConstTensor recurrentToForgetWeights(TensorInfo(
1012  4, recurrentToForgetWeightsDimensions.data(), DataType::Float32), recurrentToForgetWeightsData);
1013 
1014  std::vector<float> recurrentToCellWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
1015  std::vector<unsigned int> recurrentToCellWeightsDimensions = {1, 1, 3, 3};
1016  ConstTensor recurrentToCellWeights(TensorInfo(
1017  4, recurrentToCellWeightsDimensions.data(), DataType::Float32), recurrentToCellWeightsData);
1018 
1019  std::vector<float> recurrentToOutputWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
1020  std::vector<unsigned int> recurrentToOutputWeightsDimensions = {1, 1, 3, 3};
1021  ConstTensor recurrentToOutputWeights(TensorInfo(
1022  4, recurrentToOutputWeightsDimensions.data(), DataType::Float32), recurrentToOutputWeightsData);
1023 
1024  std::vector<float> forgetGateBiasData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
1025  std::vector<unsigned int> forgetGateBiasDimensions = {1, 1, 3, 3};
1026  ConstTensor forgetGateBias(TensorInfo(
1027  4, forgetGateBiasDimensions.data(), DataType::Float32), forgetGateBiasData);
1028 
1029  std::vector<float> cellBiasData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
1030  std::vector<unsigned int> cellBiasDimensions = {1, 1, 3, 3};
1031  ConstTensor cellBias(TensorInfo(
1032  4, cellBiasDimensions.data(), DataType::Float32), cellBiasData);
1033 
1034  std::vector<float> outputGateBiasData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
1035  std::vector<unsigned int> outputGateBiasDimensions = {1, 1, 3, 3};
1036  ConstTensor outputGateBias(TensorInfo(
1037  4, outputGateBiasDimensions.data(), DataType::Float32), outputGateBiasData);
1038 
1039  std::vector<float> cellToForgetWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
1040  std::vector<unsigned int> cellToForgetWeightsDimensions = {1, 1, 3, 3};
1041  ConstTensor cellToForgetWeights(
1042  TensorInfo(4, cellToForgetWeightsDimensions.data(), DataType::Float32), cellToForgetWeightsData);
1043 
1044  std::vector<float> cellToOutputWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
1045  std::vector<unsigned int> cellToOutputWeightsDimensions = {1, 1, 3, 3};
1046  ConstTensor cellToOutputWeights(
1047  TensorInfo(4, cellToOutputWeightsDimensions.data(), DataType::Float32), cellToOutputWeightsData);
1048 
1049  LstmInputParams params;
1050  params.m_InputToForgetWeights = &inputToForgetWeights;
1051  params.m_InputToCellWeights = &inputToCellWeights;
1052  params.m_InputToOutputWeights = &inputToOutputWeights;
1053  params.m_RecurrentToForgetWeights = &recurrentToForgetWeights;
1054  params.m_RecurrentToCellWeights = &recurrentToCellWeights;
1055  params.m_RecurrentToOutputWeights = &recurrentToOutputWeights;
1056  params.m_ForgetGateBias = &forgetGateBias;
1057  params.m_CellBias = &cellBias;
1058  params.m_OutputGateBias = &outputGateBias;
1059 
1060  params.m_CellToForgetWeights = &cellToForgetWeights;
1061  params.m_CellToOutputWeights = &cellToOutputWeights;
1062 
1063  TestLstmLayerVisitor visitor(descriptor, params);
1064 
1065  NetworkImpl net;
1066 
1067  IConnectableLayer* const layer = net.AddLstmLayer(descriptor, params);
1068  layer->Accept(visitor);
1069 }
1070 
1071 BOOST_AUTO_TEST_CASE(CheckLstmLayerPeepholeCifgDisabled)
1072 {
1073  LstmDescriptor descriptor;
1074  descriptor.m_ActivationFunc = 3;
1075  descriptor.m_ClippingThresProj = 0.5f;
1076  descriptor.m_ClippingThresCell = 0.3f;
1077  descriptor.m_CifgEnabled = false;
1078  descriptor.m_PeepholeEnabled = true;
1079 
1080  std::vector<float> inputToForgetWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
1081  std::vector<unsigned int> inputToForgetWeightsDimensions = {1, 1, 3, 3};
1082  ConstTensor inputToForgetWeights(
1083  TensorInfo(4, inputToForgetWeightsDimensions.data(), DataType::Float32), inputToForgetWeightsData);
1084 
1085  std::vector<float> inputToCellWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
1086  std::vector<unsigned int> inputToCellWeightsDimensions = {1, 1, 3, 3};
1087  ConstTensor inputToCellWeights(
1088  TensorInfo(4, inputToCellWeightsDimensions.data(), DataType::Float32), inputToCellWeightsData);
1089 
1090  std::vector<float> inputToOutputWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
1091  std::vector<unsigned int> inputToOutputWeightsDimensions = {1, 1, 3, 3};
1092  ConstTensor inputToOutputWeights(
1093  TensorInfo(4, inputToOutputWeightsDimensions.data(), DataType::Float32), inputToOutputWeightsData);
1094 
1095  std::vector<float> recurrentToForgetWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
1096  std::vector<unsigned int> recurrentToForgetWeightsDimensions = {1, 1, 3, 3};
1097  ConstTensor recurrentToForgetWeights(TensorInfo(
1098  4, recurrentToForgetWeightsDimensions.data(), DataType::Float32), recurrentToForgetWeightsData);
1099 
1100  std::vector<float> recurrentToCellWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
1101  std::vector<unsigned int> recurrentToCellWeightsDimensions = {1, 1, 3, 3};
1102  ConstTensor recurrentToCellWeights(TensorInfo(
1103  4, recurrentToCellWeightsDimensions.data(), DataType::Float32), recurrentToCellWeightsData);
1104 
1105  std::vector<float> recurrentToOutputWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
1106  std::vector<unsigned int> recurrentToOutputWeightsDimensions = {1, 1, 3, 3};
1107  ConstTensor recurrentToOutputWeights(TensorInfo(
1108  4, recurrentToOutputWeightsDimensions.data(), DataType::Float32), recurrentToOutputWeightsData);
1109 
1110  std::vector<float> forgetGateBiasData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
1111  std::vector<unsigned int> forgetGateBiasDimensions = {1, 1, 3, 3};
1112  ConstTensor forgetGateBias(TensorInfo(
1113  4, forgetGateBiasDimensions.data(), DataType::Float32), forgetGateBiasData);
1114 
1115  std::vector<float> cellBiasData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
1116  std::vector<unsigned int> cellBiasDimensions = {1, 1, 3, 3};
1117  ConstTensor cellBias(TensorInfo(
1118  4, cellBiasDimensions.data(), DataType::Float32), cellBiasData);
1119 
1120  std::vector<float> outputGateBiasData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
1121  std::vector<unsigned int> outputGateBiasDimensions = {1, 1, 3, 3};
1122  ConstTensor outputGateBias(TensorInfo(
1123  4, outputGateBiasDimensions.data(), DataType::Float32), outputGateBiasData);
1124 
1125  std::vector<float> cellToInputWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
1126  std::vector<unsigned int> cellToInputWeightsDimensions = {1, 1, 3, 3};
1127  ConstTensor cellToInputWeights(
1128  TensorInfo(4, cellToInputWeightsDimensions.data(), DataType::Float32), cellToInputWeightsData);
1129 
1130  std::vector<float> cellToForgetWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
1131  std::vector<unsigned int> cellToForgetWeightsDimensions = {1, 1, 3, 3};
1132  ConstTensor cellToForgetWeights(
1133  TensorInfo(4, cellToForgetWeightsDimensions.data(), DataType::Float32), cellToForgetWeightsData);
1134 
1135  std::vector<float> cellToOutputWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
1136  std::vector<unsigned int> cellToOutputWeightsDimensions = {1, 1, 3, 3};
1137  ConstTensor cellToOutputWeights(
1138  TensorInfo(4, cellToOutputWeightsDimensions.data(), DataType::Float32), cellToOutputWeightsData);
1139 
1140  std::vector<float> inputToInputWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
1141  std::vector<unsigned int> inputToInputWeightsDimensions = {1, 1, 3, 3};
1142  ConstTensor inputToInputWeights(
1143  TensorInfo(4, inputToInputWeightsDimensions.data(), DataType::Float32), inputToInputWeightsData);
1144 
1145  std::vector<float> recurrentToInputWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
1146  std::vector<unsigned int> recurrentToInputWeightsDimensions = {1, 1, 3, 3};
1147  ConstTensor recurrentToInputWeights(TensorInfo(
1148  4, recurrentToInputWeightsDimensions.data(), DataType::Float32), recurrentToInputWeightsData);
1149 
1150  std::vector<float> inputGateBiasData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
1151  std::vector<unsigned int> inputGateBiasDimensions = {1, 1, 3, 3};
1152  ConstTensor inputGateBias(
1153  TensorInfo(4, inputGateBiasDimensions.data(), DataType::Float32), inputGateBiasData);
1154 
1155  LstmInputParams params;
1156  // Basic params
1157  params.m_InputToForgetWeights = &inputToForgetWeights;
1158  params.m_InputToCellWeights = &inputToCellWeights;
1159  params.m_InputToOutputWeights = &inputToOutputWeights;
1160  params.m_RecurrentToForgetWeights = &recurrentToForgetWeights;
1161  params.m_RecurrentToCellWeights = &recurrentToCellWeights;
1162  params.m_RecurrentToOutputWeights = &recurrentToOutputWeights;
1163  params.m_ForgetGateBias = &forgetGateBias;
1164  params.m_CellBias = &cellBias;
1165  params.m_OutputGateBias = &outputGateBias;
1166 
1167  // Peephole params
1168  params.m_CellToInputWeights = &cellToInputWeights;
1169  params.m_CellToForgetWeights = &cellToForgetWeights;
1170  params.m_CellToOutputWeights = &cellToOutputWeights;
1171 
1172  // Cifg params
1173  params.m_InputToInputWeights = &inputToInputWeights;
1174  params.m_RecurrentToInputWeights = &recurrentToInputWeights;
1175  params.m_InputGateBias = &inputGateBias;
1176 
1177  TestLstmLayerVisitor visitor(descriptor, params);
1178 
1179  NetworkImpl net;
1180 
1181  IConnectableLayer* const layer = net.AddLstmLayer(descriptor, params);
1182  layer->Accept(visitor);
1183 }
1184 
1185 BOOST_AUTO_TEST_CASE(CheckNamedLstmLayerPeephole)
1186 {
1187  const char* layerName = "LstmLayer";
1188  LstmDescriptor descriptor;
1189  descriptor.m_ActivationFunc = 3;
1190  descriptor.m_ClippingThresProj = 0.5f;
1191  descriptor.m_ClippingThresCell = 0.3f;
1192  descriptor.m_CifgEnabled = true; // if this is true then we DON'T need to set the OptCifgParams
1193  descriptor.m_PeepholeEnabled = true;
1194 
1195  std::vector<float> inputToForgetWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
1196  std::vector<unsigned int> inputToForgetWeightsDimensions = {1, 1, 3, 3};
1197  ConstTensor inputToForgetWeights(
1198  TensorInfo(4, inputToForgetWeightsDimensions.data(), DataType::Float32), inputToForgetWeightsData);
1199 
1200  std::vector<float> inputToCellWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
1201  std::vector<unsigned int> inputToCellWeightsDimensions = {1, 1, 3, 3};
1202  ConstTensor inputToCellWeights(
1203  TensorInfo(4, inputToCellWeightsDimensions.data(), DataType::Float32), inputToCellWeightsData);
1204 
1205  std::vector<float> inputToOutputWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
1206  std::vector<unsigned int> inputToOutputWeightsDimensions = {1, 1, 3, 3};
1207  ConstTensor inputToOutputWeights(
1208  TensorInfo(4, inputToOutputWeightsDimensions.data(), DataType::Float32), inputToOutputWeightsData);
1209 
1210  std::vector<float> recurrentToForgetWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
1211  std::vector<unsigned int> recurrentToForgetWeightsDimensions = {1, 1, 3, 3};
1212  ConstTensor recurrentToForgetWeights(TensorInfo(
1213  4, recurrentToForgetWeightsDimensions.data(), DataType::Float32), recurrentToForgetWeightsData);
1214 
1215  std::vector<float> recurrentToCellWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
1216  std::vector<unsigned int> recurrentToCellWeightsDimensions = {1, 1, 3, 3};
1217  ConstTensor recurrentToCellWeights(TensorInfo(
1218  4, recurrentToCellWeightsDimensions.data(), DataType::Float32), recurrentToCellWeightsData);
1219 
1220  std::vector<float> recurrentToOutputWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
1221  std::vector<unsigned int> recurrentToOutputWeightsDimensions = {1, 1, 3, 3};
1222  ConstTensor recurrentToOutputWeights(TensorInfo(
1223  4, recurrentToOutputWeightsDimensions.data(), DataType::Float32), recurrentToOutputWeightsData);
1224 
1225  std::vector<float> forgetGateBiasData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
1226  std::vector<unsigned int> forgetGateBiasDimensions = {1, 1, 3, 3};
1227  ConstTensor forgetGateBias(TensorInfo(
1228  4, forgetGateBiasDimensions.data(), DataType::Float32), forgetGateBiasData);
1229 
1230  std::vector<float> cellBiasData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
1231  std::vector<unsigned int> cellBiasDimensions = {1, 1, 3, 3};
1232  ConstTensor cellBias(TensorInfo(
1233  4, cellBiasDimensions.data(), DataType::Float32), cellBiasData);
1234 
1235  std::vector<float> outputGateBiasData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
1236  std::vector<unsigned int> outputGateBiasDimensions = {1, 1, 3, 3};
1237  ConstTensor outputGateBias(TensorInfo(
1238  4, outputGateBiasDimensions.data(), DataType::Float32), outputGateBiasData);
1239 
1240  std::vector<float> cellToForgetWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
1241  std::vector<unsigned int> cellToForgetWeightsDimensions = {1, 1, 3, 3};
1242  ConstTensor cellToForgetWeights(
1243  TensorInfo(4, cellToForgetWeightsDimensions.data(), DataType::Float32), cellToForgetWeightsData);
1244 
1245  std::vector<float> cellToOutputWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
1246  std::vector<unsigned int> cellToOutputWeightsDimensions = {1, 1, 3, 3};
1247  ConstTensor cellToOutputWeights(
1248  TensorInfo(4, cellToOutputWeightsDimensions.data(), DataType::Float32), cellToOutputWeightsData);
1249 
1250  LstmInputParams params;
1251  params.m_InputToForgetWeights = &inputToForgetWeights;
1252  params.m_InputToCellWeights = &inputToCellWeights;
1253  params.m_InputToOutputWeights = &inputToOutputWeights;
1254  params.m_RecurrentToForgetWeights = &recurrentToForgetWeights;
1255  params.m_RecurrentToCellWeights = &recurrentToCellWeights;
1256  params.m_RecurrentToOutputWeights = &recurrentToOutputWeights;
1257  params.m_ForgetGateBias = &forgetGateBias;
1258  params.m_CellBias = &cellBias;
1259  params.m_OutputGateBias = &outputGateBias;
1260 
1261  params.m_CellToForgetWeights = &cellToForgetWeights;
1262  params.m_CellToOutputWeights = &cellToOutputWeights;
1263 
1264  TestLstmLayerVisitor visitor(descriptor, params, layerName);
1265 
1266  NetworkImpl net;
1267 
1268  IConnectableLayer* const layer = net.AddLstmLayer(descriptor, params, layerName);
1269  layer->Accept(visitor);
1270 }
1271 
1272 // TODO add one with projection
1273 BOOST_AUTO_TEST_CASE(CheckLstmLayerProjection)
1274 {
1275  LstmDescriptor descriptor;
1276  descriptor.m_ActivationFunc = 3;
1277  descriptor.m_ClippingThresProj = 0.5f;
1278  descriptor.m_ClippingThresCell = 0.3f;
1279  descriptor.m_CifgEnabled = true; // if this is true then we DON'T need to set the OptCifgParams
1280  descriptor.m_ProjectionEnabled = true;
1281 
1282  std::vector<float> inputToForgetWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
1283  std::vector<unsigned int> inputToForgetWeightsDimensions = {1, 1, 3, 3};
1284  ConstTensor inputToForgetWeights(
1285  TensorInfo(4, inputToForgetWeightsDimensions.data(), DataType::Float32), inputToForgetWeightsData);
1286 
1287  std::vector<float> inputToCellWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
1288  std::vector<unsigned int> inputToCellWeightsDimensions = {1, 1, 3, 3};
1289  ConstTensor inputToCellWeights(
1290  TensorInfo(4, inputToCellWeightsDimensions.data(), DataType::Float32), inputToCellWeightsData);
1291 
1292  std::vector<float> inputToOutputWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
1293  std::vector<unsigned int> inputToOutputWeightsDimensions = {1, 1, 3, 3};
1294  ConstTensor inputToOutputWeights(
1295  TensorInfo(4, inputToOutputWeightsDimensions.data(), DataType::Float32), inputToOutputWeightsData);
1296 
1297  std::vector<float> recurrentToForgetWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
1298  std::vector<unsigned int> recurrentToForgetWeightsDimensions = {1, 1, 3, 3};
1299  ConstTensor recurrentToForgetWeights(TensorInfo(
1300  4, recurrentToForgetWeightsDimensions.data(), DataType::Float32), recurrentToForgetWeightsData);
1301 
1302  std::vector<float> recurrentToCellWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
1303  std::vector<unsigned int> recurrentToCellWeightsDimensions = {1, 1, 3, 3};
1304  ConstTensor recurrentToCellWeights(TensorInfo(
1305  4, recurrentToCellWeightsDimensions.data(), DataType::Float32), recurrentToCellWeightsData);
1306 
1307  std::vector<float> recurrentToOutputWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
1308  std::vector<unsigned int> recurrentToOutputWeightsDimensions = {1, 1, 3, 3};
1309  ConstTensor recurrentToOutputWeights(TensorInfo(
1310  4, recurrentToOutputWeightsDimensions.data(), DataType::Float32), recurrentToOutputWeightsData);
1311 
1312  std::vector<float> forgetGateBiasData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
1313  std::vector<unsigned int> forgetGateBiasDimensions = {1, 1, 3, 3};
1314  ConstTensor forgetGateBias(TensorInfo(
1315  4, forgetGateBiasDimensions.data(), DataType::Float32), forgetGateBiasData);
1316 
1317  std::vector<float> cellBiasData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
1318  std::vector<unsigned int> cellBiasDimensions = {1, 1, 3, 3};
1319  ConstTensor cellBias(TensorInfo(
1320  4, cellBiasDimensions.data(), DataType::Float32), cellBiasData);
1321 
1322  std::vector<float> outputGateBiasData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
1323  std::vector<unsigned int> outputGateBiasDimensions = {1, 1, 3, 3};
1324  ConstTensor outputGateBias(TensorInfo(
1325  4, outputGateBiasDimensions.data(), DataType::Float32), outputGateBiasData);
1326 
1327  std::vector<float> projectionBiasData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
1328  std::vector<unsigned int> projectionBiasDimensions = {1, 1, 3, 3};
1329  ConstTensor projectionBias(
1330  TensorInfo(4, projectionBiasDimensions.data(), DataType::Float32), projectionBiasData);
1331 
1332  std::vector<float> projectionWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
1333  std::vector<unsigned int> projectionWeightsDimensions = {1, 1, 3, 3};
1334  ConstTensor projectionWeights(
1335  TensorInfo(4, projectionWeightsDimensions.data(), DataType::Float32), projectionWeightsData);
1336 
1337  LstmInputParams params;
1338  params.m_InputToForgetWeights = &inputToForgetWeights;
1339  params.m_InputToCellWeights = &inputToCellWeights;
1340  params.m_InputToOutputWeights = &inputToOutputWeights;
1341  params.m_RecurrentToForgetWeights = &recurrentToForgetWeights;
1342  params.m_RecurrentToCellWeights = &recurrentToCellWeights;
1343  params.m_RecurrentToOutputWeights = &recurrentToOutputWeights;
1344  params.m_ForgetGateBias = &forgetGateBias;
1345  params.m_CellBias = &cellBias;
1346  params.m_OutputGateBias = &outputGateBias;
1347 
1348  params.m_ProjectionWeights = &projectionWeights;
1349  params.m_ProjectionBias = &projectionBias;
1350 
1351  TestLstmLayerVisitor visitor(descriptor, params);
1352 
1353  NetworkImpl net;
1354 
1355  IConnectableLayer* const layer = net.AddLstmLayer(descriptor, params);
1356  layer->Accept(visitor);
1357 }
1358 
1359 BOOST_AUTO_TEST_CASE(CheckNamedLstmLayerProjection)
1360 {
1361  const char* layerName = "LstmLayer";
1362  LstmDescriptor descriptor;
1363  descriptor.m_ActivationFunc = 3;
1364  descriptor.m_ClippingThresProj = 0.5f;
1365  descriptor.m_ClippingThresCell = 0.3f;
1366  descriptor.m_CifgEnabled = true; // if this is true then we DON'T need to set the OptCifgParams
1367  descriptor.m_ProjectionEnabled = true;
1368 
1369  std::vector<float> inputToForgetWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
1370  std::vector<unsigned int> inputToForgetWeightsDimensions = {1, 1, 3, 3};
1371  ConstTensor inputToForgetWeights(
1372  TensorInfo(4, inputToForgetWeightsDimensions.data(), DataType::Float32), inputToForgetWeightsData);
1373 
1374  std::vector<float> inputToCellWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
1375  std::vector<unsigned int> inputToCellWeightsDimensions = {1, 1, 3, 3};
1376  ConstTensor inputToCellWeights(
1377  TensorInfo(4, inputToCellWeightsDimensions.data(), DataType::Float32), inputToCellWeightsData);
1378 
1379  std::vector<float> inputToOutputWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
1380  std::vector<unsigned int> inputToOutputWeightsDimensions = {1, 1, 3, 3};
1381  ConstTensor inputToOutputWeights(
1382  TensorInfo(4, inputToOutputWeightsDimensions.data(), DataType::Float32), inputToOutputWeightsData);
1383 
1384  std::vector<float> recurrentToForgetWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
1385  std::vector<unsigned int> recurrentToForgetWeightsDimensions = {1, 1, 3, 3};
1386  ConstTensor recurrentToForgetWeights(TensorInfo(
1387  4, recurrentToForgetWeightsDimensions.data(), DataType::Float32), recurrentToForgetWeightsData);
1388 
1389  std::vector<float> recurrentToCellWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
1390  std::vector<unsigned int> recurrentToCellWeightsDimensions = {1, 1, 3, 3};
1391  ConstTensor recurrentToCellWeights(TensorInfo(
1392  4, recurrentToCellWeightsDimensions.data(), DataType::Float32), recurrentToCellWeightsData);
1393 
1394  std::vector<float> recurrentToOutputWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
1395  std::vector<unsigned int> recurrentToOutputWeightsDimensions = {1, 1, 3, 3};
1396  ConstTensor recurrentToOutputWeights(TensorInfo(
1397  4, recurrentToOutputWeightsDimensions.data(), DataType::Float32), recurrentToOutputWeightsData);
1398 
1399  std::vector<float> forgetGateBiasData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
1400  std::vector<unsigned int> forgetGateBiasDimensions = {1, 1, 3, 3};
1401  ConstTensor forgetGateBias(TensorInfo(
1402  4, forgetGateBiasDimensions.data(), DataType::Float32), forgetGateBiasData);
1403 
1404  std::vector<float> cellBiasData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
1405  std::vector<unsigned int> cellBiasDimensions = {1, 1, 3, 3};
1406  ConstTensor cellBias(TensorInfo(
1407  4, cellBiasDimensions.data(), DataType::Float32), cellBiasData);
1408 
1409  std::vector<float> outputGateBiasData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
1410  std::vector<unsigned int> outputGateBiasDimensions = {1, 1, 3, 3};
1411  ConstTensor outputGateBias(TensorInfo(
1412  4, outputGateBiasDimensions.data(), DataType::Float32), outputGateBiasData);
1413 
1414  std::vector<float> projectionBiasData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
1415  std::vector<unsigned int> projectionBiasDimensions = {1, 1, 3, 3};
1416  ConstTensor projectionBias(
1417  TensorInfo(4, projectionBiasDimensions.data(), DataType::Float32), projectionBiasData);
1418 
1419  std::vector<float> projectionWeightsData = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
1420  std::vector<unsigned int> projectionWeightsDimensions = {1, 1, 3, 3};
1421  ConstTensor projectionWeights(
1422  TensorInfo(4, projectionWeightsDimensions.data(), DataType::Float32), projectionWeightsData);
1423 
1424  LstmInputParams params;
1425  params.m_InputToForgetWeights = &inputToForgetWeights;
1426  params.m_InputToCellWeights = &inputToCellWeights;
1427  params.m_InputToOutputWeights = &inputToOutputWeights;
1428  params.m_RecurrentToForgetWeights = &recurrentToForgetWeights;
1429  params.m_RecurrentToCellWeights = &recurrentToCellWeights;
1430  params.m_RecurrentToOutputWeights = &recurrentToOutputWeights;
1431  params.m_ForgetGateBias = &forgetGateBias;
1432  params.m_CellBias = &cellBias;
1433  params.m_OutputGateBias = &outputGateBias;
1434 
1435  params.m_ProjectionWeights = &projectionWeights;
1436  params.m_ProjectionBias = &projectionBias;
1437 
1438  TestLstmLayerVisitor visitor(descriptor, params, layerName);
1439 
1440  NetworkImpl net;
1441 
1442  IConnectableLayer* const layer = net.AddLstmLayer(descriptor, params, layerName);
1443  layer->Accept(visitor);
1444 }
1445 
1446 BOOST_AUTO_TEST_CASE(CheckQLstmLayerBasic)
1447 {
1448  QLstmDescriptor descriptor;
1449  descriptor.m_ProjectionClip = 0.5f;
1450  descriptor.m_CellClip = 0.3f;
1451  descriptor.m_CifgEnabled = true;
1452 
1453  // Basic params ONLY
1454  std::vector<uint8_t> inputToForgetWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
1455  std::vector<unsigned int> inputToForgetWeightsDimensions = {1, 1, 3, 3};
1456  ConstTensor inputToForgetWeights(
1457  TensorInfo(4, inputToForgetWeightsDimensions.data(), DataType::QSymmS8), inputToForgetWeightsData);
1458 
1459  std::vector<uint8_t> inputToCellWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
1460  std::vector<unsigned int> inputToCellWeightsDimensions = {1, 1, 3, 3};
1461  ConstTensor inputToCellWeights(
1462  TensorInfo(4, inputToCellWeightsDimensions.data(), DataType::QSymmS8), inputToCellWeightsData);
1463 
1464  std::vector<uint8_t> inputToOutputWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
1465  std::vector<unsigned int> inputToOutputWeightsDimensions = {1, 1, 3, 3};
1466  ConstTensor inputToOutputWeights(
1467  TensorInfo(4, inputToOutputWeightsDimensions.data(), DataType::QSymmS8), inputToOutputWeightsData);
1468 
1469  std::vector<uint8_t> recurrentToForgetWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
1470  std::vector<unsigned int> recurrentToForgetWeightsDimensions = {1, 1, 3, 3};
1471  ConstTensor recurrentToForgetWeights(TensorInfo(
1472  4, recurrentToForgetWeightsDimensions.data(), DataType::QSymmS8), recurrentToForgetWeightsData);
1473 
1474  std::vector<uint8_t> recurrentToCellWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
1475  std::vector<unsigned int> recurrentToCellWeightsDimensions = {1, 1, 3, 3};
1476  ConstTensor recurrentToCellWeights(TensorInfo(
1477  4, recurrentToCellWeightsDimensions.data(), DataType::QSymmS8), recurrentToCellWeightsData);
1478 
1479  std::vector<uint8_t> recurrentToOutputWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
1480  std::vector<unsigned int> recurrentToOutputWeightsDimensions = {1, 1, 3, 3};
1481  ConstTensor recurrentToOutputWeights(TensorInfo(
1482  4, recurrentToOutputWeightsDimensions.data(), DataType::QSymmS8), recurrentToOutputWeightsData);
1483 
1484  std::vector<int32_t> forgetGateBiasData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
1485  std::vector<unsigned int> forgetGateBiasDimensions = {1, 1, 3, 3};
1486  ConstTensor forgetGateBias(TensorInfo(
1487  4, forgetGateBiasDimensions.data(), DataType::Signed32), forgetGateBiasData);
1488 
1489  std::vector<int32_t> cellBiasData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
1490  std::vector<unsigned int> cellBiasDimensions = {1, 1, 3, 3};
1491  ConstTensor cellBias(TensorInfo(
1492  4, cellBiasDimensions.data(), DataType::Signed32), cellBiasData);
1493 
1494  std::vector<int32_t> outputGateBiasData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
1495  std::vector<unsigned int> outputGateBiasDimensions = {1, 1, 3, 3};
1496  ConstTensor outputGateBias(TensorInfo(
1497  4, outputGateBiasDimensions.data(), DataType::Signed32), outputGateBiasData);
1498 
1499  LstmInputParams params;
1500  params.m_InputToForgetWeights = &inputToForgetWeights;
1501  params.m_InputToCellWeights = &inputToCellWeights;
1502  params.m_InputToOutputWeights = &inputToOutputWeights;
1503  params.m_RecurrentToForgetWeights = &recurrentToForgetWeights;
1504  params.m_RecurrentToCellWeights = &recurrentToCellWeights;
1505  params.m_RecurrentToOutputWeights = &recurrentToOutputWeights;
1506  params.m_ForgetGateBias = &forgetGateBias;
1507  params.m_CellBias = &cellBias;
1508  params.m_OutputGateBias = &outputGateBias;
1509 
1510  TestQLstmLayerVisitor visitor(descriptor, params);
1511 
1512  NetworkImpl net;
1513 
1514  IConnectableLayer* const layer = net.AddQLstmLayer(descriptor, params);
1515  layer->Accept(visitor);
1516 }
1517 
1518 BOOST_AUTO_TEST_CASE(CheckNamedQLstmLayerBasic)
1519 {
1520  const char* layerName = "QLstmLayer";
1521  QLstmDescriptor descriptor;
1522  descriptor.m_ProjectionClip = 0.5f;
1523  descriptor.m_CellClip = 0.3f;
1524  descriptor.m_CifgEnabled = true;
1525 
1526  // Basic params ONLY
1527  std::vector<uint8_t> inputToForgetWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
1528  std::vector<unsigned int> inputToForgetWeightsDimensions = {1, 1, 3, 3};
1529  ConstTensor inputToForgetWeights(
1530  TensorInfo(4, inputToForgetWeightsDimensions.data(), DataType::QSymmS8), inputToForgetWeightsData);
1531 
1532  std::vector<uint8_t> inputToCellWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
1533  std::vector<unsigned int> inputToCellWeightsDimensions = {1, 1, 3, 3};
1534  ConstTensor inputToCellWeights(
1535  TensorInfo(4, inputToCellWeightsDimensions.data(), DataType::QSymmS8), inputToCellWeightsData);
1536 
1537  std::vector<uint8_t> inputToOutputWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
1538  std::vector<unsigned int> inputToOutputWeightsDimensions = {1, 1, 3, 3};
1539  ConstTensor inputToOutputWeights(
1540  TensorInfo(4, inputToOutputWeightsDimensions.data(), DataType::QSymmS8), inputToOutputWeightsData);
1541 
1542  std::vector<uint8_t> recurrentToForgetWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
1543  std::vector<unsigned int> recurrentToForgetWeightsDimensions = {1, 1, 3, 3};
1544  ConstTensor recurrentToForgetWeights(TensorInfo(
1545  4, recurrentToForgetWeightsDimensions.data(), DataType::QSymmS8), recurrentToForgetWeightsData);
1546 
1547  std::vector<uint8_t> recurrentToCellWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
1548  std::vector<unsigned int> recurrentToCellWeightsDimensions = {1, 1, 3, 3};
1549  ConstTensor recurrentToCellWeights(TensorInfo(
1550  4, recurrentToCellWeightsDimensions.data(), DataType::QSymmS8), recurrentToCellWeightsData);
1551 
1552  std::vector<uint8_t> recurrentToOutputWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
1553  std::vector<unsigned int> recurrentToOutputWeightsDimensions = {1, 1, 3, 3};
1554  ConstTensor recurrentToOutputWeights(TensorInfo(
1555  4, recurrentToOutputWeightsDimensions.data(), DataType::QSymmS8), recurrentToOutputWeightsData);
1556 
1557  std::vector<int32_t> forgetGateBiasData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
1558  std::vector<unsigned int> forgetGateBiasDimensions = {1, 1, 3, 3};
1559  ConstTensor forgetGateBias(TensorInfo(
1560  4, forgetGateBiasDimensions.data(), DataType::Signed32), forgetGateBiasData);
1561 
1562  std::vector<int32_t> cellBiasData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
1563  std::vector<unsigned int> cellBiasDimensions = {1, 1, 3, 3};
1564  ConstTensor cellBias(TensorInfo(
1565  4, cellBiasDimensions.data(), DataType::Signed32), cellBiasData);
1566 
1567  std::vector<int32_t> outputGateBiasData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
1568  std::vector<unsigned int> outputGateBiasDimensions = {1, 1, 3, 3};
1569  ConstTensor outputGateBias(TensorInfo(
1570  4, outputGateBiasDimensions.data(), DataType::Signed32), outputGateBiasData);
1571 
1572  LstmInputParams params;
1573  params.m_InputToForgetWeights = &inputToForgetWeights;
1574  params.m_InputToCellWeights = &inputToCellWeights;
1575  params.m_InputToOutputWeights = &inputToOutputWeights;
1576  params.m_RecurrentToForgetWeights = &recurrentToForgetWeights;
1577  params.m_RecurrentToCellWeights = &recurrentToCellWeights;
1578  params.m_RecurrentToOutputWeights = &recurrentToOutputWeights;
1579  params.m_ForgetGateBias = &forgetGateBias;
1580  params.m_CellBias = &cellBias;
1581  params.m_OutputGateBias = &outputGateBias;
1582 
1583  TestQLstmLayerVisitor visitor(descriptor, params, layerName);
1584 
1585  NetworkImpl net;
1586 
1587  IConnectableLayer* const layer = net.AddQLstmLayer(descriptor, params, layerName);
1588  layer->Accept(visitor);
1589 }
1590 
1591 BOOST_AUTO_TEST_CASE(CheckQLstmLayerCifgDisabled)
1592 {
1593  QLstmDescriptor descriptor;
1594  descriptor.m_ProjectionClip = 0.5f;
1595  descriptor.m_CellClip = 0.3f;
1596  descriptor.m_CifgEnabled = false;
1597 
1598  // Basic params
1599  std::vector<uint8_t> inputToForgetWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
1600  std::vector<unsigned int> inputToForgetWeightsDimensions = {1, 1, 3, 3};
1601  ConstTensor inputToForgetWeights(
1602  TensorInfo(4, inputToForgetWeightsDimensions.data(), DataType::QSymmS8), inputToForgetWeightsData);
1603 
1604  std::vector<uint8_t> inputToCellWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
1605  std::vector<unsigned int> inputToCellWeightsDimensions = {1, 1, 3, 3};
1606  ConstTensor inputToCellWeights(
1607  TensorInfo(4, inputToCellWeightsDimensions.data(), DataType::QSymmS8), inputToCellWeightsData);
1608 
1609  std::vector<uint8_t> inputToOutputWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
1610  std::vector<unsigned int> inputToOutputWeightsDimensions = {1, 1, 3, 3};
1611  ConstTensor inputToOutputWeights(
1612  TensorInfo(4, inputToOutputWeightsDimensions.data(), DataType::QSymmS8), inputToOutputWeightsData);
1613 
1614  std::vector<uint8_t> recurrentToForgetWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
1615  std::vector<unsigned int> recurrentToForgetWeightsDimensions = {1, 1, 3, 3};
1616  ConstTensor recurrentToForgetWeights(TensorInfo(
1617  4, recurrentToForgetWeightsDimensions.data(), DataType::QSymmS8), recurrentToForgetWeightsData);
1618 
1619  std::vector<uint8_t> recurrentToCellWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
1620  std::vector<unsigned int> recurrentToCellWeightsDimensions = {1, 1, 3, 3};
1621  ConstTensor recurrentToCellWeights(TensorInfo(
1622  4, recurrentToCellWeightsDimensions.data(), DataType::QSymmS8), recurrentToCellWeightsData);
1623 
1624  std::vector<uint8_t> recurrentToOutputWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
1625  std::vector<unsigned int> recurrentToOutputWeightsDimensions = {1, 1, 3, 3};
1626  ConstTensor recurrentToOutputWeights(TensorInfo(
1627  4, recurrentToOutputWeightsDimensions.data(), DataType::QSymmS8), recurrentToOutputWeightsData);
1628 
1629  std::vector<int32_t> forgetGateBiasData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
1630  std::vector<unsigned int> forgetGateBiasDimensions = {1, 1, 3, 3};
1631  ConstTensor forgetGateBias(TensorInfo(
1632  4, forgetGateBiasDimensions.data(), DataType::Signed32), forgetGateBiasData);
1633 
1634  std::vector<int32_t> cellBiasData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
1635  std::vector<unsigned int> cellBiasDimensions = {1, 1, 3, 3};
1636  ConstTensor cellBias(TensorInfo(
1637  4, cellBiasDimensions.data(), DataType::Signed32), cellBiasData);
1638 
1639  std::vector<int32_t> outputGateBiasData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
1640  std::vector<unsigned int> outputGateBiasDimensions = {1, 1, 3, 3};
1641  ConstTensor outputGateBias(TensorInfo(
1642  4, outputGateBiasDimensions.data(), DataType::Signed32), outputGateBiasData);
1643 
1644  // CIFG disabled params
1645  std::vector<uint8_t> inputToInputWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
1646  std::vector<unsigned int> inputToInputWeightsDimensions = {1, 1, 3, 3};
1647  ConstTensor inputToInputWeights(
1648  TensorInfo(4, inputToInputWeightsDimensions.data(), DataType::QSymmS8), inputToInputWeightsData);
1649 
1650  std::vector<uint8_t> recurrentToInputWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
1651  std::vector<unsigned int> recurrentToInputWeightsDimensions = {1, 1, 3, 3};
1652  ConstTensor recurrentToInputWeights(TensorInfo(
1653  4, recurrentToInputWeightsDimensions.data(), DataType::QSymmS8), recurrentToInputWeightsData);
1654 
1655  std::vector<int32_t> inputGateBiasData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
1656  std::vector<unsigned int> inputGateBiasDimensions = {1, 1, 3, 3};
1657  ConstTensor inputGateBias(
1658  TensorInfo(4, inputGateBiasDimensions.data(), DataType::Signed32), inputGateBiasData);
1659 
1660  LstmInputParams params;
1661 
1662  // Basic params
1663  params.m_InputToForgetWeights = &inputToForgetWeights;
1664  params.m_InputToCellWeights = &inputToCellWeights;
1665  params.m_InputToOutputWeights = &inputToOutputWeights;
1666  params.m_RecurrentToForgetWeights = &recurrentToForgetWeights;
1667  params.m_RecurrentToCellWeights = &recurrentToCellWeights;
1668  params.m_RecurrentToOutputWeights = &recurrentToOutputWeights;
1669  params.m_ForgetGateBias = &forgetGateBias;
1670  params.m_CellBias = &cellBias;
1671  params.m_OutputGateBias = &outputGateBias;
1672 
1673  // CIFG disabled params
1674  params.m_InputToInputWeights = &inputToInputWeights;
1675  params.m_RecurrentToInputWeights = &recurrentToInputWeights;
1676  params.m_InputGateBias = &inputGateBias;
1677 
1678  TestQLstmLayerVisitor visitor(descriptor, params);
1679 
1680  NetworkImpl net;
1681 
1682  IConnectableLayer* const layer = net.AddQLstmLayer(descriptor, params);
1683  layer->Accept(visitor);
1684 }
1685 
1686 BOOST_AUTO_TEST_CASE(CheckQLstmLayerCifgDisabledPeepholeEnabled)
1687 {
1688  QLstmDescriptor descriptor;
1689  descriptor.m_ProjectionClip = 0.5f;
1690  descriptor.m_CellClip = 0.3f;
1691  descriptor.m_CifgEnabled = false;
1692  descriptor.m_PeepholeEnabled = true;
1693 
1694  // Basic params
1695  std::vector<uint8_t> inputToForgetWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
1696  std::vector<unsigned int> inputToForgetWeightsDimensions = {1, 1, 3, 3};
1697  ConstTensor inputToForgetWeights(
1698  TensorInfo(4, inputToForgetWeightsDimensions.data(), DataType::QSymmS8), inputToForgetWeightsData);
1699 
1700  std::vector<uint8_t> inputToCellWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
1701  std::vector<unsigned int> inputToCellWeightsDimensions = {1, 1, 3, 3};
1702  ConstTensor inputToCellWeights(
1703  TensorInfo(4, inputToCellWeightsDimensions.data(), DataType::QSymmS8), inputToCellWeightsData);
1704 
1705  std::vector<uint8_t> inputToOutputWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
1706  std::vector<unsigned int> inputToOutputWeightsDimensions = {1, 1, 3, 3};
1707  ConstTensor inputToOutputWeights(
1708  TensorInfo(4, inputToOutputWeightsDimensions.data(), DataType::QSymmS8), inputToOutputWeightsData);
1709 
1710  std::vector<uint8_t> recurrentToForgetWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
1711  std::vector<unsigned int> recurrentToForgetWeightsDimensions = {1, 1, 3, 3};
1712  ConstTensor recurrentToForgetWeights(TensorInfo(
1713  4, recurrentToForgetWeightsDimensions.data(), DataType::QSymmS8), recurrentToForgetWeightsData);
1714 
1715  std::vector<uint8_t> recurrentToCellWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
1716  std::vector<unsigned int> recurrentToCellWeightsDimensions = {1, 1, 3, 3};
1717  ConstTensor recurrentToCellWeights(TensorInfo(
1718  4, recurrentToCellWeightsDimensions.data(), DataType::QSymmS8), recurrentToCellWeightsData);
1719 
1720  std::vector<uint8_t> recurrentToOutputWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
1721  std::vector<unsigned int> recurrentToOutputWeightsDimensions = {1, 1, 3, 3};
1722  ConstTensor recurrentToOutputWeights(TensorInfo(
1723  4, recurrentToOutputWeightsDimensions.data(), DataType::QSymmS8), recurrentToOutputWeightsData);
1724 
1725  std::vector<int32_t> forgetGateBiasData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
1726  std::vector<unsigned int> forgetGateBiasDimensions = {1, 1, 3, 3};
1727  ConstTensor forgetGateBias(TensorInfo(
1728  4, forgetGateBiasDimensions.data(), DataType::Signed32), forgetGateBiasData);
1729 
1730  std::vector<int32_t> cellBiasData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
1731  std::vector<unsigned int> cellBiasDimensions = {1, 1, 3, 3};
1732  ConstTensor cellBias(TensorInfo(
1733  4, cellBiasDimensions.data(), DataType::Signed32), cellBiasData);
1734 
1735  std::vector<int32_t> outputGateBiasData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
1736  std::vector<unsigned int> outputGateBiasDimensions = {1, 1, 3, 3};
1737  ConstTensor outputGateBias(TensorInfo(
1738  4, outputGateBiasDimensions.data(), DataType::Signed32), outputGateBiasData);
1739 
1740  // CIFG disabled params
1741  std::vector<uint8_t> inputToInputWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
1742  std::vector<unsigned int> inputToInputWeightsDimensions = {1, 1, 3, 3};
1743  ConstTensor inputToInputWeights(
1744  TensorInfo(4, inputToInputWeightsDimensions.data(), DataType::QSymmS8), inputToInputWeightsData);
1745 
1746  std::vector<uint8_t> recurrentToInputWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
1747  std::vector<unsigned int> recurrentToInputWeightsDimensions = {1, 1, 3, 3};
1748  ConstTensor recurrentToInputWeights(TensorInfo(
1749  4, recurrentToInputWeightsDimensions.data(), DataType::QSymmS8), recurrentToInputWeightsData);
1750 
1751  std::vector<int32_t> inputGateBiasData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
1752  std::vector<unsigned int> inputGateBiasDimensions = {1, 1, 3, 3};
1753  ConstTensor inputGateBias(
1754  TensorInfo(4, inputGateBiasDimensions.data(), DataType::Signed32), inputGateBiasData);
1755 
1756  // Peephole enabled, CIFG disabled params
1757  std::vector<int16_t> cellToInputWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
1758  std::vector<unsigned int> cellToInputWeightsDimensions = {1, 1, 3, 3};
1759  ConstTensor cellToInputWeights(
1760  TensorInfo(4, cellToInputWeightsDimensions.data(), DataType::QSymmS16), cellToInputWeightsData);
1761 
1762  std::vector<int16_t> cellToForgetWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
1763  std::vector<unsigned int> cellToForgetWeightsDimensions = {1, 1, 3, 3};
1764  ConstTensor cellToForgetWeights(
1765  TensorInfo(4, cellToForgetWeightsDimensions.data(), DataType::QSymmS16), cellToForgetWeightsData);
1766 
1767  std::vector<int16_t> cellToOutputWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
1768  std::vector<unsigned int> cellToOutputWeightsDimensions = {1, 1, 3, 3};
1769  ConstTensor cellToOutputWeights(
1770  TensorInfo(4, cellToOutputWeightsDimensions.data(), DataType::QSymmS16), cellToOutputWeightsData);
1771 
1772  LstmInputParams params;
1773 
1774  // Basic params
1775  params.m_InputToForgetWeights = &inputToForgetWeights;
1776  params.m_InputToCellWeights = &inputToCellWeights;
1777  params.m_InputToOutputWeights = &inputToOutputWeights;
1778  params.m_RecurrentToForgetWeights = &recurrentToForgetWeights;
1779  params.m_RecurrentToCellWeights = &recurrentToCellWeights;
1780  params.m_RecurrentToOutputWeights = &recurrentToOutputWeights;
1781  params.m_ForgetGateBias = &forgetGateBias;
1782  params.m_CellBias = &cellBias;
1783  params.m_OutputGateBias = &outputGateBias;
1784 
1785  // CIFG disabled params
1786  params.m_InputToInputWeights = &inputToInputWeights;
1787  params.m_RecurrentToInputWeights = &recurrentToInputWeights;
1788  params.m_InputGateBias = &inputGateBias;
1789 
1790  // Peephole enabled, CIFG disabled params
1791  params.m_CellToInputWeights = &cellToInputWeights;
1792  params.m_CellToForgetWeights = &cellToForgetWeights;
1793  params.m_CellToOutputWeights = &cellToOutputWeights;
1794 
1795  TestQLstmLayerVisitor visitor(descriptor, params);
1796 
1797  NetworkImpl net;
1798 
1799  IConnectableLayer* const layer = net.AddQLstmLayer(descriptor, params);
1800  layer->Accept(visitor);
1801 }
1802 
1803 BOOST_AUTO_TEST_CASE(CheckQLstmLayerCifgEnabledPeepholeEnabled)
1804 {
1805  QLstmDescriptor descriptor;
1806  descriptor.m_ProjectionClip = 0.5f;
1807  descriptor.m_CellClip = 0.3f;
1808  descriptor.m_CifgEnabled = true;
1809  descriptor.m_PeepholeEnabled = true;
1810 
1811  // Basic params
1812  std::vector<uint8_t> inputToForgetWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
1813  std::vector<unsigned int> inputToForgetWeightsDimensions = {1, 1, 3, 3};
1814  ConstTensor inputToForgetWeights(
1815  TensorInfo(4, inputToForgetWeightsDimensions.data(), DataType::QSymmS8), inputToForgetWeightsData);
1816 
1817  std::vector<uint8_t> inputToCellWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
1818  std::vector<unsigned int> inputToCellWeightsDimensions = {1, 1, 3, 3};
1819  ConstTensor inputToCellWeights(
1820  TensorInfo(4, inputToCellWeightsDimensions.data(), DataType::QSymmS8), inputToCellWeightsData);
1821 
1822  std::vector<uint8_t> inputToOutputWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
1823  std::vector<unsigned int> inputToOutputWeightsDimensions = {1, 1, 3, 3};
1824  ConstTensor inputToOutputWeights(
1825  TensorInfo(4, inputToOutputWeightsDimensions.data(), DataType::QSymmS8), inputToOutputWeightsData);
1826 
1827  std::vector<uint8_t> recurrentToForgetWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
1828  std::vector<unsigned int> recurrentToForgetWeightsDimensions = {1, 1, 3, 3};
1829  ConstTensor recurrentToForgetWeights(TensorInfo(
1830  4, recurrentToForgetWeightsDimensions.data(), DataType::QSymmS8), recurrentToForgetWeightsData);
1831 
1832  std::vector<uint8_t> recurrentToCellWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
1833  std::vector<unsigned int> recurrentToCellWeightsDimensions = {1, 1, 3, 3};
1834  ConstTensor recurrentToCellWeights(TensorInfo(
1835  4, recurrentToCellWeightsDimensions.data(), DataType::QSymmS8), recurrentToCellWeightsData);
1836 
1837  std::vector<uint8_t> recurrentToOutputWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
1838  std::vector<unsigned int> recurrentToOutputWeightsDimensions = {1, 1, 3, 3};
1839  ConstTensor recurrentToOutputWeights(TensorInfo(
1840  4, recurrentToOutputWeightsDimensions.data(), DataType::QSymmS8), recurrentToOutputWeightsData);
1841 
1842  std::vector<int32_t> forgetGateBiasData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
1843  std::vector<unsigned int> forgetGateBiasDimensions = {1, 1, 3, 3};
1844  ConstTensor forgetGateBias(TensorInfo(
1845  4, forgetGateBiasDimensions.data(), DataType::Signed32), forgetGateBiasData);
1846 
1847  std::vector<int32_t> cellBiasData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
1848  std::vector<unsigned int> cellBiasDimensions = {1, 1, 3, 3};
1849  ConstTensor cellBias(TensorInfo(
1850  4, cellBiasDimensions.data(), DataType::Signed32), cellBiasData);
1851 
1852  std::vector<int32_t> outputGateBiasData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
1853  std::vector<unsigned int> outputGateBiasDimensions = {1, 1, 3, 3};
1854  ConstTensor outputGateBias(TensorInfo(
1855  4, outputGateBiasDimensions.data(), DataType::Signed32), outputGateBiasData);
1856 
1857  // Peephole enabled and CIFG enabled params
1858  std::vector<int16_t> cellToForgetWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
1859  std::vector<unsigned int> cellToForgetWeightsDimensions = {1, 1, 3, 3};
1860  ConstTensor cellToForgetWeights(
1861  TensorInfo(4, cellToForgetWeightsDimensions.data(), DataType::QSymmS16), cellToForgetWeightsData);
1862 
1863  std::vector<int16_t> cellToOutputWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
1864  std::vector<unsigned int> cellToOutputWeightsDimensions = {1, 1, 3, 3};
1865  ConstTensor cellToOutputWeights(
1866  TensorInfo(4, cellToOutputWeightsDimensions.data(), DataType::QSymmS16), cellToOutputWeightsData);
1867 
1868  LstmInputParams params;
1869 
1870  // Basic params
1871  params.m_InputToForgetWeights = &inputToForgetWeights;
1872  params.m_InputToCellWeights = &inputToCellWeights;
1873  params.m_InputToOutputWeights = &inputToOutputWeights;
1874  params.m_RecurrentToForgetWeights = &recurrentToForgetWeights;
1875  params.m_RecurrentToCellWeights = &recurrentToCellWeights;
1876  params.m_RecurrentToOutputWeights = &recurrentToOutputWeights;
1877  params.m_ForgetGateBias = &forgetGateBias;
1878  params.m_CellBias = &cellBias;
1879  params.m_OutputGateBias = &outputGateBias;
1880 
1881  // Peephole enabled and CIFG enabled params
1882  params.m_CellToForgetWeights = &cellToForgetWeights;
1883  params.m_CellToOutputWeights = &cellToOutputWeights;
1884 
1885  TestQLstmLayerVisitor visitor(descriptor, params);
1886 
1887  NetworkImpl net;
1888 
1889  IConnectableLayer* const layer = net.AddQLstmLayer(descriptor, params);
1890  layer->Accept(visitor);
1891 }
1892 
1893 BOOST_AUTO_TEST_CASE(CheckQLstmLayerProjectionEnabled)
1894 {
1895  QLstmDescriptor descriptor;
1896  descriptor.m_ProjectionClip = 0.5f;
1897  descriptor.m_CellClip = 0.3f;
1898  descriptor.m_CifgEnabled = true;
1899  descriptor.m_ProjectionEnabled = true;
1900 
1901  // Basic params ONLY
1902  std::vector<uint8_t> inputToForgetWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
1903  std::vector<unsigned int> inputToForgetWeightsDimensions = {1, 1, 3, 3};
1904  ConstTensor inputToForgetWeights(
1905  TensorInfo(4, inputToForgetWeightsDimensions.data(), DataType::QSymmS8), inputToForgetWeightsData);
1906 
1907  std::vector<uint8_t> inputToCellWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
1908  std::vector<unsigned int> inputToCellWeightsDimensions = {1, 1, 3, 3};
1909  ConstTensor inputToCellWeights(
1910  TensorInfo(4, inputToCellWeightsDimensions.data(), DataType::QSymmS8), inputToCellWeightsData);
1911 
1912  std::vector<uint8_t> inputToOutputWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
1913  std::vector<unsigned int> inputToOutputWeightsDimensions = {1, 1, 3, 3};
1914  ConstTensor inputToOutputWeights(
1915  TensorInfo(4, inputToOutputWeightsDimensions.data(), DataType::QSymmS8), inputToOutputWeightsData);
1916 
1917  std::vector<uint8_t> recurrentToForgetWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
1918  std::vector<unsigned int> recurrentToForgetWeightsDimensions = {1, 1, 3, 3};
1919  ConstTensor recurrentToForgetWeights(TensorInfo(
1920  4, recurrentToForgetWeightsDimensions.data(), DataType::QSymmS8), recurrentToForgetWeightsData);
1921 
1922  std::vector<uint8_t> recurrentToCellWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
1923  std::vector<unsigned int> recurrentToCellWeightsDimensions = {1, 1, 3, 3};
1924  ConstTensor recurrentToCellWeights(TensorInfo(
1925  4, recurrentToCellWeightsDimensions.data(), DataType::QSymmS8), recurrentToCellWeightsData);
1926 
1927  std::vector<uint8_t> recurrentToOutputWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
1928  std::vector<unsigned int> recurrentToOutputWeightsDimensions = {1, 1, 3, 3};
1929  ConstTensor recurrentToOutputWeights(TensorInfo(
1930  4, recurrentToOutputWeightsDimensions.data(), DataType::QSymmS8), recurrentToOutputWeightsData);
1931 
1932  std::vector<int32_t> forgetGateBiasData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
1933  std::vector<unsigned int> forgetGateBiasDimensions = {1, 1, 3, 3};
1934  ConstTensor forgetGateBias(TensorInfo(
1935  4, forgetGateBiasDimensions.data(), DataType::Signed32), forgetGateBiasData);
1936 
1937  std::vector<int32_t> cellBiasData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
1938  std::vector<unsigned int> cellBiasDimensions = {1, 1, 3, 3};
1939  ConstTensor cellBias(TensorInfo(
1940  4, cellBiasDimensions.data(), DataType::Signed32), cellBiasData);
1941 
1942  std::vector<int32_t> outputGateBiasData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
1943  std::vector<unsigned int> outputGateBiasDimensions = {1, 1, 3, 3};
1944  ConstTensor outputGateBias(TensorInfo(
1945  4, outputGateBiasDimensions.data(), DataType::Signed32), outputGateBiasData);
1946 
1947  // Projection enabled params
1948  std::vector<uint8_t> projectionWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
1949  std::vector<unsigned int> projectionWeightsDimensions = {1, 1, 3, 3};
1950  ConstTensor projectionWeights(TensorInfo(
1951  4, projectionWeightsDimensions.data(), DataType::QSymmS8), projectionWeightsData);
1952 
1953  std::vector<int32_t> projectionBiasData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
1954  std::vector<unsigned int> projectionBiasDimensions = {1, 1, 3, 3};
1955  ConstTensor projectionBias(TensorInfo(
1956  4, projectionBiasDimensions.data(), DataType::Signed32), projectionBiasData);
1957 
1958  LstmInputParams params;
1959 
1960  // Basic params
1961  params.m_InputToForgetWeights = &inputToForgetWeights;
1962  params.m_InputToCellWeights = &inputToCellWeights;
1963  params.m_InputToOutputWeights = &inputToOutputWeights;
1964  params.m_RecurrentToForgetWeights = &recurrentToForgetWeights;
1965  params.m_RecurrentToCellWeights = &recurrentToCellWeights;
1966  params.m_RecurrentToOutputWeights = &recurrentToOutputWeights;
1967  params.m_ForgetGateBias = &forgetGateBias;
1968  params.m_CellBias = &cellBias;
1969  params.m_OutputGateBias = &outputGateBias;
1970 
1971  // Projection enabled params
1972  params.m_ProjectionWeights = &projectionWeights;
1973  params.m_ProjectionBias = &projectionBias;
1974 
1975  TestQLstmLayerVisitor visitor(descriptor, params);
1976 
1977  NetworkImpl net;
1978 
1979  IConnectableLayer* const layer = net.AddQLstmLayer(descriptor, params);
1980  layer->Accept(visitor);
1981 }
1982 
1983 BOOST_AUTO_TEST_CASE(CheckQLstmLayerCifgDisabledLayerNormEnabled)
1984 {
1985  QLstmDescriptor descriptor;
1986  descriptor.m_ProjectionClip = 0.5f;
1987  descriptor.m_CellClip = 0.3f;
1988  descriptor.m_CifgEnabled = false;
1989  descriptor.m_LayerNormEnabled = true;
1990 
1991  // Basic params
1992  std::vector<uint8_t> inputToForgetWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
1993  std::vector<unsigned int> inputToForgetWeightsDimensions = {1, 1, 3, 3};
1994  ConstTensor inputToForgetWeights(
1995  TensorInfo(4, inputToForgetWeightsDimensions.data(), DataType::QSymmS8), inputToForgetWeightsData);
1996 
1997  std::vector<uint8_t> inputToCellWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
1998  std::vector<unsigned int> inputToCellWeightsDimensions = {1, 1, 3, 3};
1999  ConstTensor inputToCellWeights(
2000  TensorInfo(4, inputToCellWeightsDimensions.data(), DataType::QSymmS8), inputToCellWeightsData);
2001 
2002  std::vector<uint8_t> inputToOutputWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
2003  std::vector<unsigned int> inputToOutputWeightsDimensions = {1, 1, 3, 3};
2004  ConstTensor inputToOutputWeights(
2005  TensorInfo(4, inputToOutputWeightsDimensions.data(), DataType::QSymmS8), inputToOutputWeightsData);
2006 
2007  std::vector<uint8_t> recurrentToForgetWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
2008  std::vector<unsigned int> recurrentToForgetWeightsDimensions = {1, 1, 3, 3};
2009  ConstTensor recurrentToForgetWeights(TensorInfo(
2010  4, recurrentToForgetWeightsDimensions.data(), DataType::QSymmS8), recurrentToForgetWeightsData);
2011 
2012  std::vector<uint8_t> recurrentToCellWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
2013  std::vector<unsigned int> recurrentToCellWeightsDimensions = {1, 1, 3, 3};
2014  ConstTensor recurrentToCellWeights(TensorInfo(
2015  4, recurrentToCellWeightsDimensions.data(), DataType::QSymmS8), recurrentToCellWeightsData);
2016 
2017  std::vector<uint8_t> recurrentToOutputWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
2018  std::vector<unsigned int> recurrentToOutputWeightsDimensions = {1, 1, 3, 3};
2019  ConstTensor recurrentToOutputWeights(TensorInfo(
2020  4, recurrentToOutputWeightsDimensions.data(), DataType::QSymmS8), recurrentToOutputWeightsData);
2021 
2022  std::vector<int32_t> forgetGateBiasData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
2023  std::vector<unsigned int> forgetGateBiasDimensions = {1, 1, 3, 3};
2024  ConstTensor forgetGateBias(TensorInfo(
2025  4, forgetGateBiasDimensions.data(), DataType::Signed32), forgetGateBiasData);
2026 
2027  std::vector<int32_t> cellBiasData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
2028  std::vector<unsigned int> cellBiasDimensions = {1, 1, 3, 3};
2029  ConstTensor cellBias(TensorInfo(
2030  4, cellBiasDimensions.data(), DataType::Signed32), cellBiasData);
2031 
2032  std::vector<int32_t> outputGateBiasData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
2033  std::vector<unsigned int> outputGateBiasDimensions = {1, 1, 3, 3};
2034  ConstTensor outputGateBias(TensorInfo(
2035  4, outputGateBiasDimensions.data(), DataType::Signed32), outputGateBiasData);
2036 
2037  // CIFG disabled params
2038  std::vector<uint8_t> inputToInputWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
2039  std::vector<unsigned int> inputToInputWeightsDimensions = {1, 1, 3, 3};
2040  ConstTensor inputToInputWeights(
2041  TensorInfo(4, inputToInputWeightsDimensions.data(), DataType::QSymmS8), inputToInputWeightsData);
2042 
2043  std::vector<uint8_t> recurrentToInputWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
2044  std::vector<unsigned int> recurrentToInputWeightsDimensions = {1, 1, 3, 3};
2045  ConstTensor recurrentToInputWeights(TensorInfo(
2046  4, recurrentToInputWeightsDimensions.data(), DataType::QSymmS8), recurrentToInputWeightsData);
2047 
2048  std::vector<int32_t> inputGateBiasData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
2049  std::vector<unsigned int> inputGateBiasDimensions = {1, 1, 3, 3};
2050  ConstTensor inputGateBias(
2051  TensorInfo(4, inputGateBiasDimensions.data(), DataType::Signed32), inputGateBiasData);
2052 
2053  // Layer Norm enabled, CIFG disabled params
2054  std::vector<int16_t> inputLayerNormWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
2055  std::vector<unsigned int> inputLayerNormWeightsDimensions = {1, 1, 3, 3};
2056  ConstTensor inputLayerNormWeights(
2057  TensorInfo(4, inputLayerNormWeightsDimensions.data(), DataType::QSymmS16), inputLayerNormWeightsData);
2058 
2059  std::vector<int16_t> forgetLayerNormWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
2060  std::vector<unsigned int> forgetLayerNormWeightsDimensions = {1, 1, 3, 3};
2061  ConstTensor forgetLayerNormWeights(
2062  TensorInfo(4, forgetLayerNormWeightsDimensions.data(), DataType::QSymmS16), forgetLayerNormWeightsData);
2063 
2064  std::vector<int16_t> cellLayerNormWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
2065  std::vector<unsigned int> cellLayerNormWeightsDimensions = {1, 1, 3, 3};
2066  ConstTensor cellLayerNormWeights(
2067  TensorInfo(4, cellLayerNormWeightsDimensions.data(), DataType::QSymmS16), cellLayerNormWeightsData);
2068 
2069  std::vector<int16_t> outputLayerNormWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
2070  std::vector<unsigned int> outputLayerNormWeightsDimensions = {1, 1, 3, 3};
2071  ConstTensor outputLayerNormWeights(
2072  TensorInfo(4, outputLayerNormWeightsDimensions.data(), DataType::QSymmS16), outputLayerNormWeightsData);
2073 
2074  LstmInputParams params;
2075 
2076  // Basic params
2077  params.m_InputToForgetWeights = &inputToForgetWeights;
2078  params.m_InputToCellWeights = &inputToCellWeights;
2079  params.m_InputToOutputWeights = &inputToOutputWeights;
2080  params.m_RecurrentToForgetWeights = &recurrentToForgetWeights;
2081  params.m_RecurrentToCellWeights = &recurrentToCellWeights;
2082  params.m_RecurrentToOutputWeights = &recurrentToOutputWeights;
2083  params.m_ForgetGateBias = &forgetGateBias;
2084  params.m_CellBias = &cellBias;
2085  params.m_OutputGateBias = &outputGateBias;
2086 
2087  // CIFG disabled params
2088  params.m_InputToInputWeights = &inputToInputWeights;
2089  params.m_RecurrentToInputWeights = &recurrentToInputWeights;
2090  params.m_InputGateBias = &inputGateBias;
2091 
2092  // Layer Norm enabled, CIFG disabled params
2093  params.m_InputLayerNormWeights = &inputLayerNormWeights;
2094  params.m_ForgetLayerNormWeights = &forgetLayerNormWeights;
2095  params.m_CellLayerNormWeights = &cellLayerNormWeights;
2096  params.m_OutputLayerNormWeights = &outputLayerNormWeights;
2097 
2098  TestQLstmLayerVisitor visitor(descriptor, params);
2099 
2100  NetworkImpl net;
2101 
2102  IConnectableLayer* const layer = net.AddQLstmLayer(descriptor, params);
2103  layer->Accept(visitor);
2104 }
2105 
2106 
2107 BOOST_AUTO_TEST_CASE(CheckQuantizedLstmLayer)
2108 {
2109  std::vector<uint8_t> inputToInputWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
2110  std::vector<unsigned int> inputToInputWeightsDimensions = {1, 1, 3, 3};
2111  ConstTensor inputToInputWeights(
2112  TensorInfo(4, inputToInputWeightsDimensions.data(), DataType::QSymmS8), inputToInputWeightsData);
2113 
2114  std::vector<uint8_t> inputToForgetWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
2115  std::vector<unsigned int> inputToForgetWeightsDimensions = {1, 1, 3, 3};
2116  ConstTensor inputToForgetWeights(
2117  TensorInfo(4, inputToForgetWeightsDimensions.data(), DataType::QSymmS8), inputToForgetWeightsData);
2118 
2119  std::vector<uint8_t> inputToCellWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
2120  std::vector<unsigned int> inputToCellWeightsDimensions = {1, 1, 3, 3};
2121  ConstTensor inputToCellWeights(
2122  TensorInfo(4, inputToCellWeightsDimensions.data(), DataType::QSymmS8), inputToCellWeightsData);
2123 
2124  std::vector<uint8_t> inputToOutputWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
2125  std::vector<unsigned int> inputToOutputWeightsDimensions = {1, 1, 3, 3};
2126  ConstTensor inputToOutputWeights(
2127  TensorInfo(4, inputToOutputWeightsDimensions.data(), DataType::QSymmS8), inputToOutputWeightsData);
2128 
2129 
2130  std::vector<uint8_t> recurrentToInputWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
2131  std::vector<unsigned int> recurrentToInputWeightsDimensions = {1, 1, 3, 3};
2132  ConstTensor recurrentToInputWeights(TensorInfo(
2133  4, recurrentToInputWeightsDimensions.data(), DataType::QSymmS8), recurrentToInputWeightsData);
2134 
2135  std::vector<uint8_t> recurrentToForgetWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
2136  std::vector<unsigned int> recurrentToForgetWeightsDimensions = {1, 1, 3, 3};
2137  ConstTensor recurrentToForgetWeights(TensorInfo(
2138  4, recurrentToForgetWeightsDimensions.data(), DataType::QSymmS8), recurrentToForgetWeightsData);
2139 
2140  std::vector<uint8_t> recurrentToCellWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
2141  std::vector<unsigned int> recurrentToCellWeightsDimensions = {1, 1, 3, 3};
2142  ConstTensor recurrentToCellWeights(TensorInfo(
2143  4, recurrentToCellWeightsDimensions.data(), DataType::QSymmS8), recurrentToCellWeightsData);
2144 
2145  std::vector<uint8_t> recurrentToOutputWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
2146  std::vector<unsigned int> recurrentToOutputWeightsDimensions = {1, 1, 3, 3};
2147  ConstTensor recurrentToOutputWeights(TensorInfo(
2148  4, recurrentToOutputWeightsDimensions.data(), DataType::QSymmS8), recurrentToOutputWeightsData);
2149 
2150 
2151  std::vector<int32_t> inputGateBiasData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
2152  std::vector<unsigned int> inputGateBiasDimensions = {1, 1, 3, 3};
2153  ConstTensor inputGateBias(
2154  TensorInfo(4, inputGateBiasDimensions.data(), DataType::Signed32), inputGateBiasData);
2155 
2156  std::vector<int32_t> forgetGateBiasData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
2157  std::vector<unsigned int> forgetGateBiasDimensions = {1, 1, 3, 3};
2158  ConstTensor forgetGateBias(TensorInfo(
2159  4, forgetGateBiasDimensions.data(), DataType::Signed32), forgetGateBiasData);
2160 
2161  std::vector<int32_t> cellBiasData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
2162  std::vector<unsigned int> cellBiasDimensions = {1, 1, 3, 3};
2163  ConstTensor cellBias(TensorInfo(
2164  4, cellBiasDimensions.data(), DataType::Signed32), cellBiasData);
2165 
2166  std::vector<int32_t> outputGateBiasData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
2167  std::vector<unsigned int> outputGateBiasDimensions = {1, 1, 3, 3};
2168  ConstTensor outputGateBias(TensorInfo(
2169  4, outputGateBiasDimensions.data(), DataType::Signed32), outputGateBiasData);
2170 
2171  QuantizedLstmInputParams params;
2172 
2173  params.m_InputToInputWeights = &inputToInputWeights;
2174  params.m_InputToForgetWeights = &inputToForgetWeights;
2175  params.m_InputToCellWeights = &inputToCellWeights;
2176  params.m_InputToOutputWeights = &inputToOutputWeights;
2177 
2178  params.m_RecurrentToInputWeights = &recurrentToInputWeights;
2179  params.m_RecurrentToForgetWeights = &recurrentToForgetWeights;
2180  params.m_RecurrentToCellWeights = &recurrentToCellWeights;
2181  params.m_RecurrentToOutputWeights = &recurrentToOutputWeights;
2182 
2183  params.m_InputGateBias = &inputGateBias;
2184  params.m_ForgetGateBias = &forgetGateBias;
2185  params.m_CellBias = &cellBias;
2186  params.m_OutputGateBias = &outputGateBias;
2187 
2188  TestQuantizedLstmLayerVisitor visitor(params);
2189 
2190  NetworkImpl net;
2191 
2192  IConnectableLayer* const layer = net.AddQuantizedLstmLayer(params);
2193  layer->Accept(visitor);
2194 }
2195 
2196 BOOST_AUTO_TEST_CASE(CheckNamedQuantizedLstmLayer)
2197 {
2198  const char* layerName = "LstmLayer";
2199  std::vector<uint8_t> inputToInputWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
2200  std::vector<unsigned int> inputToInputWeightsDimensions = {1, 1, 3, 3};
2201  ConstTensor inputToInputWeights(
2202  TensorInfo(4, inputToInputWeightsDimensions.data(), DataType::QAsymmU8), inputToInputWeightsData);
2203 
2204  std::vector<uint8_t> inputToForgetWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
2205  std::vector<unsigned int> inputToForgetWeightsDimensions = {1, 1, 3, 3};
2206  ConstTensor inputToForgetWeights(
2207  TensorInfo(4, inputToForgetWeightsDimensions.data(), DataType::QAsymmU8), inputToForgetWeightsData);
2208 
2209  std::vector<uint8_t> inputToCellWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
2210  std::vector<unsigned int> inputToCellWeightsDimensions = {1, 1, 3, 3};
2211  ConstTensor inputToCellWeights(
2212  TensorInfo(4, inputToCellWeightsDimensions.data(), DataType::QAsymmU8), inputToCellWeightsData);
2213 
2214  std::vector<uint8_t> inputToOutputWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
2215  std::vector<unsigned int> inputToOutputWeightsDimensions = {1, 1, 3, 3};
2216  ConstTensor inputToOutputWeights(
2217  TensorInfo(4, inputToOutputWeightsDimensions.data(), DataType::QAsymmU8), inputToOutputWeightsData);
2218 
2219 
2220  std::vector<uint8_t> recurrentToInputWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
2221  std::vector<unsigned int> recurrentToInputWeightsDimensions = {1, 1, 3, 3};
2222  ConstTensor recurrentToInputWeights(TensorInfo(
2223  4, recurrentToInputWeightsDimensions.data(), DataType::QAsymmU8), recurrentToInputWeightsData);
2224 
2225  std::vector<uint8_t> recurrentToForgetWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
2226  std::vector<unsigned int> recurrentToForgetWeightsDimensions = {1, 1, 3, 3};
2227  ConstTensor recurrentToForgetWeights(TensorInfo(
2228  4, recurrentToForgetWeightsDimensions.data(), DataType::QAsymmU8), recurrentToForgetWeightsData);
2229 
2230  std::vector<uint8_t> recurrentToCellWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
2231  std::vector<unsigned int> recurrentToCellWeightsDimensions = {1, 1, 3, 3};
2232  ConstTensor recurrentToCellWeights(TensorInfo(
2233  4, recurrentToCellWeightsDimensions.data(), DataType::QAsymmU8), recurrentToCellWeightsData);
2234 
2235  std::vector<uint8_t> recurrentToOutputWeightsData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
2236  std::vector<unsigned int> recurrentToOutputWeightsDimensions = {1, 1, 3, 3};
2237  ConstTensor recurrentToOutputWeights(TensorInfo(
2238  4, recurrentToOutputWeightsDimensions.data(), DataType::QAsymmU8), recurrentToOutputWeightsData);
2239 
2240 
2241  std::vector<int32_t> inputGateBiasData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
2242  std::vector<unsigned int> inputGateBiasDimensions = {1, 1, 3, 3};
2243  ConstTensor inputGateBias(
2244  TensorInfo(4, inputGateBiasDimensions.data(), DataType::Signed32), inputGateBiasData);
2245 
2246  std::vector<int32_t> forgetGateBiasData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
2247  std::vector<unsigned int> forgetGateBiasDimensions = {1, 1, 3, 3};
2248  ConstTensor forgetGateBias(TensorInfo(
2249  4, forgetGateBiasDimensions.data(), DataType::Signed32), forgetGateBiasData);
2250 
2251  std::vector<int32_t> cellBiasData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
2252  std::vector<unsigned int> cellBiasDimensions = {1, 1, 3, 3};
2253  ConstTensor cellBias(TensorInfo(
2254  4, cellBiasDimensions.data(), DataType::Signed32), cellBiasData);
2255 
2256  std::vector<int32_t> outputGateBiasData = {1, 2, 3, 4, 5, 6, 7, 8, 9};
2257  std::vector<unsigned int> outputGateBiasDimensions = {1, 1, 3, 3};
2258  ConstTensor outputGateBias(TensorInfo(
2259  4, outputGateBiasDimensions.data(), DataType::Signed32), outputGateBiasData);
2260 
2261  QuantizedLstmInputParams params;
2262 
2263  params.m_InputToInputWeights = &inputToInputWeights;
2264  params.m_InputToForgetWeights = &inputToForgetWeights;
2265  params.m_InputToCellWeights = &inputToCellWeights;
2266  params.m_InputToOutputWeights = &inputToOutputWeights;
2267 
2268  params.m_RecurrentToInputWeights = &recurrentToInputWeights;
2269  params.m_RecurrentToForgetWeights = &recurrentToForgetWeights;
2270  params.m_RecurrentToCellWeights = &recurrentToCellWeights;
2271  params.m_RecurrentToOutputWeights = &recurrentToOutputWeights;
2272 
2273  params.m_InputGateBias = &inputGateBias;
2274  params.m_ForgetGateBias = &forgetGateBias;
2275  params.m_CellBias = &cellBias;
2276  params.m_OutputGateBias = &outputGateBias;
2277 
2278  TestQuantizedLstmLayerVisitor visitor(params, layerName);
2279 
2280  NetworkImpl net;
2281 
2282  IConnectableLayer* const layer = net.AddQuantizedLstmLayer(params, layerName);
2283  layer->Accept(visitor);
2284 }
2285 
2286 BOOST_AUTO_TEST_SUITE_END()
2287 
2288 } // namespace armnn
armnn::TestBatchNormalizationLayerVisitor::CheckDescriptor
void CheckDescriptor(const BatchNormalizationDescriptor &descriptor)
Definition: ConstTensorLayerVisitor.cpp:45
BOOST_AUTO_TEST_SUITE
BOOST_AUTO_TEST_SUITE(TensorflowLiteParser)
armnn::TestQLstmLayerVisitor::CheckDescriptor
void CheckDescriptor(const QLstmDescriptor &descriptor)
Definition: ConstTensorLayerVisitor.cpp:128
armnn::Convolution2dDescriptor::m_PadBottom
uint32_t m_PadBottom
Padding bottom value in the height dimension.
Definition: Descriptors.hpp:444
armnn::Convolution2dDescriptor::m_BiasEnabled
bool m_BiasEnabled
Enable/disable bias.
Definition: Descriptors.hpp:454
armnn::TestLstmLayerVisitor::CheckConstTensorPtrs
void CheckConstTensorPtrs(const std::string &name, const ConstTensor *expected, const ConstTensor *actual)
Definition: ConstTensorLayerVisitor.cpp:61
armnn::LstmDescriptor::m_ProjectionEnabled
bool m_ProjectionEnabled
Enable/disable the projection layer.
Definition: Descriptors.hpp:945
armnn::Convolution2dDescriptor::m_DataLayout
DataLayout m_DataLayout
The data layout to be used (NCHW, NHWC).
Definition: Descriptors.hpp:456
armnn::LstmInputParams::m_ProjectionWeights
const ConstTensor * m_ProjectionWeights
Definition: LstmParams.hpp:55
armnn::IConnectableLayer
Interface for a layer that is connectable to other layers via InputSlots and OutputSlots.
Definition: INetwork.hpp:62
armnn::LstmInputParams::m_CellBias
const ConstTensor * m_CellBias
Definition: LstmParams.hpp:53
armnn::DepthwiseConvolution2dDescriptor::m_BiasEnabled
bool m_BiasEnabled
Enable/disable bias.
Definition: Descriptors.hpp:506
armnn::QuantizedLstmInputParams::m_RecurrentToOutputWeights
const ConstTensor * m_RecurrentToOutputWeights
Definition: QuantizedLstmParams.hpp:41
armnn::DepthwiseConvolution2dDescriptor::m_PadBottom
uint32_t m_PadBottom
Padding bottom value in the height dimension.
Definition: Descriptors.hpp:496
armnn::NetworkImpl::AddFullyConnectedLayer
IConnectableLayer * AddFullyConnectedLayer(const FullyConnectedDescriptor &fullyConnectedDescriptor, const ConstTensor &weights, const Optional< ConstTensor > &biases, const char *name=nullptr)
Definition: Network.cpp:1733
armnn::LstmDescriptor::m_ClippingThresProj
float m_ClippingThresProj
Clipping threshold value for the projection.
Definition: Descriptors.hpp:939
armnn::LstmInputParams::m_CellToOutputWeights
const ConstTensor * m_CellToOutputWeights
Definition: LstmParams.hpp:50
armnn::QuantizedLstmInputParams::m_RecurrentToForgetWeights
const ConstTensor * m_RecurrentToForgetWeights
Definition: QuantizedLstmParams.hpp:39
armnn::DepthwiseConvolution2dDescriptor::m_DataLayout
DataLayout m_DataLayout
The data layout to be used (NCHW, NHWC).
Definition: Descriptors.hpp:508
armnn::FullyConnectedDescriptor::m_TransposeWeightMatrix
bool m_TransposeWeightMatrix
Enable/disable transpose weight matrix.
Definition: Descriptors.hpp:404
armnn::TestFullyConnectedLayerVistor::CheckDescriptor
void CheckDescriptor(const FullyConnectedDescriptor &descriptor)
Definition: ConstTensorLayerVisitor.cpp:39
armnn::QLstmDescriptor::m_PeepholeEnabled
bool m_PeepholeEnabled
Enable/disable peephole.
Definition: Descriptors.hpp:1193
armnn::Convolution2dDescriptor
A Convolution2dDescriptor for the Convolution2dLayer.
Definition: Descriptors.hpp:408
armnn::DepthwiseConvolution2dDescriptor::m_PadLeft
uint32_t m_PadLeft
Padding left value in the width dimension.
Definition: Descriptors.hpp:490
armnn::NetworkImpl::AddQuantizedLstmLayer
IConnectableLayer * AddQuantizedLstmLayer(const QuantizedLstmInputParams &params, const char *name=nullptr)
Definition: Network.cpp:2319
armnn::LstmInputParams::m_CellToInputWeights
const ConstTensor * m_CellToInputWeights
Definition: LstmParams.hpp:48
armnn::NetworkImpl::AddConstantLayer
IConnectableLayer * AddConstantLayer(const ConstTensor &input, const char *name=nullptr)
Definition: Network.cpp:2027
armnn::BatchNormalizationDescriptor::m_Eps
float m_Eps
Value to add to the variance. Used to avoid dividing by zero.
Definition: Descriptors.hpp:639
armnn::LstmInputParams::m_InputGateBias
const ConstTensor * m_InputGateBias
Definition: LstmParams.hpp:51
armnn::BatchNormalizationDescriptor::m_DataLayout
DataLayout m_DataLayout
The data layout to be used (NCHW, NHWC).
Definition: Descriptors.hpp:641
armnn::LstmInputParams::m_RecurrentToCellWeights
const ConstTensor * m_RecurrentToCellWeights
Definition: LstmParams.hpp:46
armnn::Convolution2dDescriptor::m_PadRight
uint32_t m_PadRight
Padding right value in the width dimension.
Definition: Descriptors.hpp:440
armnn::LstmInputParams::m_ForgetLayerNormWeights
const ConstTensor * m_ForgetLayerNormWeights
Definition: LstmParams.hpp:58
armnn::LstmInputParams::m_CellToForgetWeights
const ConstTensor * m_CellToForgetWeights
Definition: LstmParams.hpp:49
armnn
Copyright (c) 2021 ARM Limited and Contributors.
Definition: 01_00_software_tools.dox:6
armnn::NetworkImpl::AddDepthwiseConvolution2dLayer
IConnectableLayer * AddDepthwiseConvolution2dLayer(const DepthwiseConvolution2dDescriptor &convolution2dDescriptor, const ConstTensor &weights, const Optional< ConstTensor > &biases, const char *name=nullptr)
Definition: Network.cpp:1840
armnn::NetworkImpl
Private implementation of INetwork.
Definition: Network.hpp:31
armnn::LstmInputParams::m_OutputGateBias
const ConstTensor * m_OutputGateBias
Definition: LstmParams.hpp:54
armnn::TestLayerVisitor::CheckConstTensors
void CheckConstTensors(const ConstTensor &expected, const ConstTensor &actual)
Definition: TestLayerVisitor.cpp:33
armnn::Convolution2dDescriptor::m_PadTop
uint32_t m_PadTop
Padding top value in the height dimension.
Definition: Descriptors.hpp:442
armnn::Convolution2dDescriptor::m_StrideX
uint32_t m_StrideX
Stride value when proceeding through input for the width dimension.
Definition: Descriptors.hpp:446
armnn::NetworkImpl::AddQLstmLayer
IConnectableLayer * AddQLstmLayer(const QLstmDescriptor &descriptor, const LstmInputParams &params, const char *name=nullptr)
Definition: Network.cpp:2357
armnn::LstmInputParams::m_InputLayerNormWeights
const ConstTensor * m_InputLayerNormWeights
Definition: LstmParams.hpp:57
armnn::DepthwiseConvolution2dDescriptor::m_StrideX
uint32_t m_StrideX
Stride value when proceeding through input for the width dimension.
Definition: Descriptors.hpp:498
armnn::TestQLstmLayerVisitor::CheckInputParameters
void CheckInputParameters(const LstmInputParams &inputParams)
Definition: ConstTensorLayerVisitor.cpp:137
armnn::QLstmDescriptor::m_LayerNormEnabled
bool m_LayerNormEnabled
Enable/disable layer normalization.
Definition: Descriptors.hpp:1197
armnn::LstmInputParams::m_RecurrentToOutputWeights
const ConstTensor * m_RecurrentToOutputWeights
Definition: LstmParams.hpp:47
ConstTensorLayerVisitor.hpp
armnn::LstmDescriptor
An LstmDescriptor for the LstmLayer.
Definition: Descriptors.hpp:911
armnn::DepthwiseConvolution2dDescriptor::m_PadTop
uint32_t m_PadTop
Padding top value in the height dimension.
Definition: Descriptors.hpp:494
armnn::TestLstmLayerVisitor::CheckDescriptor
void CheckDescriptor(const LstmDescriptor &descriptor)
Definition: ConstTensorLayerVisitor.cpp:51
armnn::LstmInputParams::m_ProjectionBias
const ConstTensor * m_ProjectionBias
Definition: LstmParams.hpp:56
armnn::QuantizedLstmInputParams::m_InputToForgetWeights
const ConstTensor * m_InputToForgetWeights
Definition: QuantizedLstmParams.hpp:34
armnn::QLstmDescriptor::m_ProjectionClip
float m_ProjectionClip
Clipping threshold value for the projection.
Definition: Descriptors.hpp:1189
armnn::FullyConnectedDescriptor
A FullyConnectedDescriptor for the FullyConnectedLayer.
Definition: Descriptors.hpp:389
armnn::FullyConnectedDescriptor::m_BiasEnabled
bool m_BiasEnabled
Enable/disable bias.
Definition: Descriptors.hpp:402
armnn::ConstTensor
A tensor defined by a TensorInfo (shape and data type) and an immutable backing store.
Definition: Tensor.hpp:314
armnn::LstmDescriptor::m_PeepholeEnabled
bool m_PeepholeEnabled
Enable/disable peephole.
Definition: Descriptors.hpp:943
armnn::TestConvolution2dLayerVisitor::CheckDescriptor
void CheckDescriptor(const Convolution2dDescriptor &convolution2dDescriptor)
Definition: ConstTensorLayerVisitor.cpp:14
armnn::QLstmDescriptor
A QLstmDescriptor for the QLstmLayer.
Definition: Descriptors.hpp:1153
armnn::TestLstmLayerVisitor::CheckInputParameters
void CheckInputParameters(const LstmInputParams &inputParams)
Definition: ConstTensorLayerVisitor.cpp:79
armnn::BOOST_AUTO_TEST_CASE
BOOST_AUTO_TEST_CASE(CheckConvolution2dLayer)
Definition: ConstTensorLayerVisitor.cpp:268
armnn::TestQuantizedLstmLayerVisitor::CheckInputParameters
void CheckInputParameters(const QuantizedLstmInputParams &inputParams)
Definition: ConstTensorLayerVisitor.cpp:226
armnn::LstmDescriptor::m_ActivationFunc
uint32_t m_ActivationFunc
The activation function to use.
Definition: Descriptors.hpp:935
armnn::Convolution2dDescriptor::m_StrideY
uint32_t m_StrideY
Stride value when proceeding through input for the height dimension.
Definition: Descriptors.hpp:448
armnn::TestDepthwiseConvolution2dLayerVisitor::CheckDescriptor
void CheckDescriptor(const DepthwiseConvolution2dDescriptor &convolution2dDescriptor)
Definition: ConstTensorLayerVisitor.cpp:26
armnn::QuantizedLstmInputParams::m_RecurrentToInputWeights
const ConstTensor * m_RecurrentToInputWeights
Definition: QuantizedLstmParams.hpp:38
armnn::LstmDescriptor::m_ClippingThresCell
float m_ClippingThresCell
Clipping threshold value for the cell state.
Definition: Descriptors.hpp:937
armnn::LstmInputParams::m_CellLayerNormWeights
const ConstTensor * m_CellLayerNormWeights
Definition: LstmParams.hpp:59
armnn::LstmInputParams::m_ForgetGateBias
const ConstTensor * m_ForgetGateBias
Definition: LstmParams.hpp:52
armnn::LstmInputParams::m_InputToCellWeights
const ConstTensor * m_InputToCellWeights
Definition: LstmParams.hpp:42
armnn::LstmInputParams::m_InputToOutputWeights
const ConstTensor * m_InputToOutputWeights
Definition: LstmParams.hpp:43
armnn::QLstmDescriptor::m_CellClip
float m_CellClip
Clipping threshold value for the cell state.
Definition: Descriptors.hpp:1187
BOOST_AUTO_TEST_SUITE_END
BOOST_AUTO_TEST_SUITE_END()
armnn::LstmDescriptor::m_CifgEnabled
bool m_CifgEnabled
Enable/disable cifg (coupled input & forget gate).
Definition: Descriptors.hpp:941
armnn::EmptyOptional
EmptyOptional is used to initialize the Optional class in case we want to have default value for an O...
Definition: Optional.hpp:32
armnn::LstmInputParams::m_RecurrentToForgetWeights
const ConstTensor * m_RecurrentToForgetWeights
Definition: LstmParams.hpp:45
armnn::DepthwiseConvolution2dDescriptor::m_StrideY
uint32_t m_StrideY
Stride value when proceeding through input for the height dimension.
Definition: Descriptors.hpp:500
armnn::IConnectableLayer::Accept
virtual void Accept(ILayerVisitor &visitor) const =0
Apply a visitor to this layer.
armnn::QLstmDescriptor::m_ProjectionEnabled
bool m_ProjectionEnabled
Enable/disable the projection layer.
Definition: Descriptors.hpp:1195
Network.hpp
armnn::QuantizedLstmInputParams::m_RecurrentToCellWeights
const ConstTensor * m_RecurrentToCellWeights
Definition: QuantizedLstmParams.hpp:40
armnn::LstmInputParams::m_RecurrentToInputWeights
const ConstTensor * m_RecurrentToInputWeights
Definition: LstmParams.hpp:44
armnn::QuantizedLstmInputParams::m_InputToOutputWeights
const ConstTensor * m_InputToOutputWeights
Definition: QuantizedLstmParams.hpp:36
armnn::TestQLstmLayerVisitor::CheckConstTensorPtrs
void CheckConstTensorPtrs(const std::string &name, const ConstTensor *expected, const ConstTensor *actual)
Definition: ConstTensorLayerVisitor.cpp:110
armnn::NetworkImpl::AddBatchNormalizationLayer
IConnectableLayer * AddBatchNormalizationLayer(const BatchNormalizationDescriptor &desc, const ConstTensor &mean, const ConstTensor &variance, const ConstTensor &beta, const ConstTensor &gamma, const char *name=nullptr)
Definition: Network.cpp:1962
armnn::LstmInputParams::m_OutputLayerNormWeights
const ConstTensor * m_OutputLayerNormWeights
Definition: LstmParams.hpp:60
armnn::TestQuantizedLstmLayerVisitor::CheckConstTensorPtrs
void CheckConstTensorPtrs(const std::string &name, const ConstTensor *expected, const ConstTensor *actual)
Definition: ConstTensorLayerVisitor.cpp:208
armnn::NetworkImpl::AddConvolution2dLayer
IConnectableLayer * AddConvolution2dLayer(const Convolution2dDescriptor &convolution2dDescriptor, const ConstTensor &weights, const Optional< ConstTensor > &biases, const char *name=nullptr)
Definition: Network.cpp:1786
armnn::NetworkImpl::AddLstmLayer
IConnectableLayer * AddLstmLayer(const LstmDescriptor &descriptor, const LstmInputParams &params, const char *name=nullptr)
Definition: Network.cpp:2059
armnn::QLstmDescriptor::m_CifgEnabled
bool m_CifgEnabled
Enable/disable CIFG (coupled input & forget gate).
Definition: Descriptors.hpp:1191
armnn::DepthwiseConvolution2dDescriptor
A DepthwiseConvolution2dDescriptor for the DepthwiseConvolution2dLayer.
Definition: Descriptors.hpp:460
armnn::BatchNormalizationDescriptor
A BatchNormalizationDescriptor for the BatchNormalizationLayer.
Definition: Descriptors.hpp:626
armnn::Convolution2dDescriptor::m_PadLeft
uint32_t m_PadLeft
Padding left value in the width dimension.
Definition: Descriptors.hpp:438
armnn::LstmInputParams::m_InputToForgetWeights
const ConstTensor * m_InputToForgetWeights
Definition: LstmParams.hpp:41
armnn::DepthwiseConvolution2dDescriptor::m_PadRight
uint32_t m_PadRight
Padding right value in the width dimension.
Definition: Descriptors.hpp:492
armnn::LstmInputParams::m_InputToInputWeights
const ConstTensor * m_InputToInputWeights
Definition: LstmParams.hpp:40