CONV_2D with per-channel quantization.

Variant of CONV_2D operand that takes:
- TENSOR_QUANT8_ASYMM as input tensor.
- TENSOR_QUANT8_ASYMM as output tensor.
- TENSOR_INT32 as bias tensor.
- TENSOR_QUANT8_SYMM_PER_CHANNEL as filter tensor.

Filter tensor channel dimension has to be 0.

Bias tensor scale value has to be 0. Its actual
scaling values depends on its position:
 bias[d].scale = input_tensor.scale * filter.scales[d]
We may want introduce TENSOR_INT32_PER_CHANNEL for
validation of biases scaling.

Added tests lack 'weights-as-input' variants, due to
VTS binary being too large on ARM  due to added size,
will be added in following CLs (tracked in b/120014519).

Added support for Operand extraParams field in NNAPI
tests:
 - SymmPerChannelQuantParams class in NeuralNetworksWrapper
that holds scales array.
- CTS/VTS test generator supports Operand with extraParams,
support for per-channel quantization extraParams.
- VTS test generator is tiny bit awkward with its extraParams
handling, safe_union makes it impossible to create operand in
initializer, hence the ExtraParams object creation before Operands.

Added 2 basic tests, with and without memory layout parameter.
Added TestValidateOperations variant for new CONV_2D.

Bug: 119255406
Test: Vts/Cts NNAPI tests.
Change-Id: Icf1aff63e6838022b9c1b56814fcf0c9baeada3c
Merged-In: Icf1aff63e6838022b9c1b56814fcf0c9baeada3c
(cherry picked from commit 62d25a684f61d367a856062390a8725a658507a5)

1 files changed, 31 insertions, 1 deletions

diff --git a/nn/runtime/test/TestNeuralNetworksWrapper.h b/nn/runtime/test/TestNeuralNetworksWrapper.h
index 9e58abe2c..1031d2ba4 100644
--- a/nn/runtime/test/TestNeuralNetworksWrapper.h
+++ b/nn/runtime/test/TestNeuralNetworksWrapper.h
@@ -61,18 +61,48 @@ enum class Result {
     BAD_STATE = ANEURALNETWORKS_BAD_STATE,
 };
 
+struct SymmPerChannelQuantParams {
+    ANeuralNetworksSymmPerChannelQuantParams params;
+    std::vector<float> scales;
+
+    SymmPerChannelQuantParams(std::vector<float> scalesVec, uint32_t channelDim)
+        : scales(std::move(scalesVec)) {
+        params = {.scaleCount = static_cast<uint32_t>(scales.size()),
+                  .scales = scales.size() > 0 ? scales.data() : nullptr,
+                  .channelDim = channelDim};
+    }
+};
+
 struct OperandType {
     ANeuralNetworksOperandType operandType;
     std::vector<uint32_t> dimensions;
 
+    SymmPerChannelQuantParams channelQuant;
+
     OperandType(Type type, std::vector<uint32_t> d, float scale = 0.0f, int32_t zeroPoint = 0)
-        : dimensions(std::move(d)) {
+        : dimensions(std::move(d)), channelQuant({}, 0) {
+        operandType = {
+                .type = static_cast<int32_t>(type),
+                .dimensionCount = static_cast<uint32_t>(dimensions.size()),
+                .dimensions = dimensions.size() > 0 ? dimensions.data() : nullptr,
+                .scale = scale,
+                .zeroPoint = zeroPoint,
+        };
+    }
+
+    OperandType(Type type, std::vector<uint32_t> data, float scale, int32_t zeroPoint,
+                SymmPerChannelQuantParams&& channelQuant)
+        : dimensions(std::move(data)), channelQuant(std::move(channelQuant)) {
         operandType = {
                 .type = static_cast<int32_t>(type),
                 .dimensionCount = static_cast<uint32_t>(dimensions.size()),
                 .dimensions = dimensions.size() > 0 ? dimensions.data() : nullptr,
                 .scale = scale,
                 .zeroPoint = zeroPoint,
+                .extraParams =
+                        {
+                                .channelQuant = channelQuant.params,
+                        },
         };
     }
 };