Google Git
Sign in
android / platform / frameworks / ml / a6c9aae8bbc8fb25f63d7fae6262bd63668375a9 / . / nn / runtime / test / generated / spec_V1_3 / space_to_batch_quant8_signed.example.cpp
blob: 56453e200520e329c91f5f2b29e0ed34f5bd84af [file] [log] [blame]
// Generated from space_to_batch_quant8_signed.mod.py
// DO NOT EDIT
// clang-format off
#include "TestHarness.h"
using namespace test_helper;
namespace generated_tests::space_to_batch_quant8_signed {
const TestModel& get_test_model() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {0},
.operands = {{ // input
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-127, -126, -125, -124, -123, -122, -121, -120, -119, -118, -117, -116, -115, -114, -113, -112}),
.dimensions = {1, 4, 4, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 1.0f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}, { // block_size
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({2, 2}),
.dimensions = {2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // paddings
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({0, 0, 0, 0}),
.dimensions = {2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // output
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-127, -125, -119, -117, -126, -124, -118, -116, -123, -121, -115, -113, -122, -120, -114, -112}),
.dimensions = {4, 2, 2, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 1.0f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}},
.operations = {{
.inputs = {0, 1, 2},
.outputs = {3},
.type = TestOperationType::SPACE_TO_BATCH_ND
}},
.outputIndexes = {3}
},
.minSupportedVersion = TestHalVersion::V1_3,
.referenced = {}
};
return model;
}
const auto dummy_test_model = TestModelManager::get().add("space_to_batch_quant8_signed", get_test_model());
} // namespace generated_tests::space_to_batch_quant8_signed
namespace generated_tests::space_to_batch_quant8_signed {
const TestModel& get_test_model_all_inputs_as_internal() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {4},
.operands = {{ // input
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({}),
.dimensions = {1, 4, 4, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
.numberOfConsumers = 1,
.scale = 1.0f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}, { // block_size
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({2, 2}),
.dimensions = {2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // paddings
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({0, 0, 0, 0}),
.dimensions = {2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // output
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-127, -125, -119, -117, -126, -124, -118, -116, -123, -121, -115, -113, -122, -120, -114, -112}),
.dimensions = {4, 2, 2, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 1.0f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}, { // input_new
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-127, -126, -125, -124, -123, -122, -121, -120, -119, -118, -117, -116, -115, -114, -113, -112}),
.dimensions = {1, 4, 4, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 1.0f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}, { // placeholder
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-128}),
.dimensions = {1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 1.0f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}, { // param4
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({0}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::INT32,
.zeroPoint = 0
}},
.operations = {{
.inputs = {4, 5, 6},
.outputs = {0},
.type = TestOperationType::ADD
}, {
.inputs = {0, 1, 2},
.outputs = {3},
.type = TestOperationType::SPACE_TO_BATCH_ND
}},
.outputIndexes = {3}
},
.minSupportedVersion = TestHalVersion::V1_3,
.referenced = {}
};
return model;
}
const auto dummy_test_model_all_inputs_as_internal = TestModelManager::get().add("space_to_batch_quant8_signed_all_inputs_as_internal", get_test_model_all_inputs_as_internal());
} // namespace generated_tests::space_to_batch_quant8_signed
namespace generated_tests::space_to_batch_quant8_signed {
const TestModel& get_test_model_all_tensors_as_inputs() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {0, 1, 2},
.operands = {{ // input
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-127, -126, -125, -124, -123, -122, -121, -120, -119, -118, -117, -116, -115, -114, -113, -112}),
.dimensions = {1, 4, 4, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 1.0f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}, { // block_size
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({2, 2}),
.dimensions = {2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // paddings
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({0, 0, 0, 0}),
.dimensions = {2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // output
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-127, -125, -119, -117, -126, -124, -118, -116, -123, -121, -115, -113, -122, -120, -114, -112}),
.dimensions = {4, 2, 2, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 1.0f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}},
.operations = {{
.inputs = {0, 1, 2},
.outputs = {3},
.type = TestOperationType::SPACE_TO_BATCH_ND
}},
.outputIndexes = {3}
},
.minSupportedVersion = TestHalVersion::V1_3,
.referenced = {}
};
return model;
}
const auto dummy_test_model_all_tensors_as_inputs = TestModelManager::get().add("space_to_batch_quant8_signed_all_tensors_as_inputs", get_test_model_all_tensors_as_inputs());
} // namespace generated_tests::space_to_batch_quant8_signed
namespace generated_tests::space_to_batch_quant8_signed {
const TestModel& get_test_model_all_tensors_as_inputs_all_inputs_as_internal() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {1, 2, 4},
.operands = {{ // input
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({}),
.dimensions = {1, 4, 4, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
.numberOfConsumers = 1,
.scale = 1.0f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}, { // block_size
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({2, 2}),
.dimensions = {2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // paddings
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({0, 0, 0, 0}),
.dimensions = {2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // output
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-127, -125, -119, -117, -126, -124, -118, -116, -123, -121, -115, -113, -122, -120, -114, -112}),
.dimensions = {4, 2, 2, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 1.0f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}, { // input_new
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-127, -126, -125, -124, -123, -122, -121, -120, -119, -118, -117, -116, -115, -114, -113, -112}),
.dimensions = {1, 4, 4, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 1.0f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}, { // placeholder1
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-128}),
.dimensions = {1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 1.0f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}, { // param5
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({0}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::INT32,
.zeroPoint = 0
}},
.operations = {{
.inputs = {4, 5, 6},
.outputs = {0},
.type = TestOperationType::ADD
}, {
.inputs = {0, 1, 2},
.outputs = {3},
.type = TestOperationType::SPACE_TO_BATCH_ND
}},
.outputIndexes = {3}
},
.minSupportedVersion = TestHalVersion::V1_3,
.referenced = {}
};
return model;
}
const auto dummy_test_model_all_tensors_as_inputs_all_inputs_as_internal = TestModelManager::get().add("space_to_batch_quant8_signed_all_tensors_as_inputs_all_inputs_as_internal", get_test_model_all_tensors_as_inputs_all_inputs_as_internal());
} // namespace generated_tests::space_to_batch_quant8_signed
namespace generated_tests::space_to_batch_quant8_signed {
const TestModel& get_test_model_2() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {0},
.operands = {{ // input1
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-127, -126, -125, -124, -123, -122, -121, -120, -119, -118}),
.dimensions = {1, 5, 2, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 1.0f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}, { // block_size1
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({3, 2}),
.dimensions = {2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // paddings1
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({1, 0, 2, 0}),
.dimensions = {2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // output1
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-128, -128, -128, -123, -128, -128, -128, -122, -128, -127, -128, -121, -128, -126, -128, -120, -128, -125, -128, -119, -128, -124, -128, -118}),
.dimensions = {6, 2, 2, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 1.0f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}},
.operations = {{
.inputs = {0, 1, 2},
.outputs = {3},
.type = TestOperationType::SPACE_TO_BATCH_ND
}},
.outputIndexes = {3}
},
.minSupportedVersion = TestHalVersion::V1_3,
.referenced = {}
};
return model;
}
const auto dummy_test_model_2 = TestModelManager::get().add("space_to_batch_quant8_signed_2", get_test_model_2());
} // namespace generated_tests::space_to_batch_quant8_signed
namespace generated_tests::space_to_batch_quant8_signed {
const TestModel& get_test_model_all_inputs_as_internal_2() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {4},
.operands = {{ // input1
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({}),
.dimensions = {1, 5, 2, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
.numberOfConsumers = 1,
.scale = 1.0f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}, { // block_size1
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({3, 2}),
.dimensions = {2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // paddings1
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({1, 0, 2, 0}),
.dimensions = {2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // output1
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-128, -128, -128, -123, -128, -128, -128, -122, -128, -127, -128, -121, -128, -126, -128, -120, -128, -125, -128, -119, -128, -124, -128, -118}),
.dimensions = {6, 2, 2, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 1.0f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}, { // input1_new
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-127, -126, -125, -124, -123, -122, -121, -120, -119, -118}),
.dimensions = {1, 5, 2, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 1.0f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}, { // placeholder2
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-128}),
.dimensions = {1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 1.0f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}, { // param6
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({0}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::INT32,
.zeroPoint = 0
}},
.operations = {{
.inputs = {4, 5, 6},
.outputs = {0},
.type = TestOperationType::ADD
}, {
.inputs = {0, 1, 2},
.outputs = {3},
.type = TestOperationType::SPACE_TO_BATCH_ND
}},
.outputIndexes = {3}
},
.minSupportedVersion = TestHalVersion::V1_3,
.referenced = {}
};
return model;
}
const auto dummy_test_model_all_inputs_as_internal_2 = TestModelManager::get().add("space_to_batch_quant8_signed_all_inputs_as_internal_2", get_test_model_all_inputs_as_internal_2());
} // namespace generated_tests::space_to_batch_quant8_signed
namespace generated_tests::space_to_batch_quant8_signed {
const TestModel& get_test_model_all_tensors_as_inputs_2() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {0, 1, 2},
.operands = {{ // input1
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-127, -126, -125, -124, -123, -122, -121, -120, -119, -118}),
.dimensions = {1, 5, 2, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 1.0f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}, { // block_size1
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({3, 2}),
.dimensions = {2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // paddings1
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({1, 0, 2, 0}),
.dimensions = {2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // output1
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-128, -128, -128, -123, -128, -128, -128, -122, -128, -127, -128, -121, -128, -126, -128, -120, -128, -125, -128, -119, -128, -124, -128, -118}),
.dimensions = {6, 2, 2, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 1.0f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}},
.operations = {{
.inputs = {0, 1, 2},
.outputs = {3},
.type = TestOperationType::SPACE_TO_BATCH_ND
}},
.outputIndexes = {3}
},
.minSupportedVersion = TestHalVersion::V1_3,
.referenced = {}
};
return model;
}
const auto dummy_test_model_all_tensors_as_inputs_2 = TestModelManager::get().add("space_to_batch_quant8_signed_all_tensors_as_inputs_2", get_test_model_all_tensors_as_inputs_2());
} // namespace generated_tests::space_to_batch_quant8_signed
namespace generated_tests::space_to_batch_quant8_signed {
const TestModel& get_test_model_all_tensors_as_inputs_all_inputs_as_internal_2() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {1, 2, 4},
.operands = {{ // input1
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({}),
.dimensions = {1, 5, 2, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
.numberOfConsumers = 1,
.scale = 1.0f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}, { // block_size1
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({3, 2}),
.dimensions = {2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // paddings1
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({1, 0, 2, 0}),
.dimensions = {2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // output1
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-128, -128, -128, -123, -128, -128, -128, -122, -128, -127, -128, -121, -128, -126, -128, -120, -128, -125, -128, -119, -128, -124, -128, -118}),
.dimensions = {6, 2, 2, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 1.0f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}, { // input1_new
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-127, -126, -125, -124, -123, -122, -121, -120, -119, -118}),
.dimensions = {1, 5, 2, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 1.0f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}, { // placeholder3
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-128}),
.dimensions = {1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 1.0f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}, { // param7
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({0}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::INT32,
.zeroPoint = 0
}},
.operations = {{
.inputs = {4, 5, 6},
.outputs = {0},
.type = TestOperationType::ADD
}, {
.inputs = {0, 1, 2},
.outputs = {3},
.type = TestOperationType::SPACE_TO_BATCH_ND
}},
.outputIndexes = {3}
},
.minSupportedVersion = TestHalVersion::V1_3,
.referenced = {}
};
return model;
}
const auto dummy_test_model_all_tensors_as_inputs_all_inputs_as_internal_2 = TestModelManager::get().add("space_to_batch_quant8_signed_all_tensors_as_inputs_all_inputs_as_internal_2", get_test_model_all_tensors_as_inputs_all_inputs_as_internal_2());
} // namespace generated_tests::space_to_batch_quant8_signed
namespace generated_tests::space_to_batch_quant8_signed {
const TestModel& get_test_model_3() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {0},
.operands = {{ // input2
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-127, -126, -125, -124, -123, -122, -121, -120}),
.dimensions = {1, 4, 2, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 1.0f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}, { // block_size2
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({3, 2}),
.dimensions = {2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // paddings2
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({1, 1, 2, 4}),
.dimensions = {2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // output2
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-128, -128, -128, -128, -128, -123, -128, -128, -128, -128, -128, -128, -128, -122, -128, -128, -128, -127, -128, -128, -128, -121, -128, -128, -128, -126, -128, -128, -128, -120, -128, -128, -128, -125, -128, -128, -128, -128, -128, -128, -128, -124, -128, -128, -128, -128, -128, -128}),
.dimensions = {6, 2, 4, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 1.0f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}},
.operations = {{
.inputs = {0, 1, 2},
.outputs = {3},
.type = TestOperationType::SPACE_TO_BATCH_ND
}},
.outputIndexes = {3}
},
.minSupportedVersion = TestHalVersion::V1_3,
.referenced = {}
};
return model;
}
const auto dummy_test_model_3 = TestModelManager::get().add("space_to_batch_quant8_signed_3", get_test_model_3());
} // namespace generated_tests::space_to_batch_quant8_signed
namespace generated_tests::space_to_batch_quant8_signed {
const TestModel& get_test_model_all_inputs_as_internal_3() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {4},
.operands = {{ // input2
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({}),
.dimensions = {1, 4, 2, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
.numberOfConsumers = 1,
.scale = 1.0f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}, { // block_size2
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({3, 2}),
.dimensions = {2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // paddings2
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({1, 1, 2, 4}),
.dimensions = {2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // output2
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-128, -128, -128, -128, -128, -123, -128, -128, -128, -128, -128, -128, -128, -122, -128, -128, -128, -127, -128, -128, -128, -121, -128, -128, -128, -126, -128, -128, -128, -120, -128, -128, -128, -125, -128, -128, -128, -128, -128, -128, -128, -124, -128, -128, -128, -128, -128, -128}),
.dimensions = {6, 2, 4, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 1.0f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}, { // input2_new
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-127, -126, -125, -124, -123, -122, -121, -120}),
.dimensions = {1, 4, 2, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 1.0f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}, { // placeholder4
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-128}),
.dimensions = {1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 1.0f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}, { // param8
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({0}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::INT32,
.zeroPoint = 0
}},
.operations = {{
.inputs = {4, 5, 6},
.outputs = {0},
.type = TestOperationType::ADD
}, {
.inputs = {0, 1, 2},
.outputs = {3},
.type = TestOperationType::SPACE_TO_BATCH_ND
}},
.outputIndexes = {3}
},
.minSupportedVersion = TestHalVersion::V1_3,
.referenced = {}
};
return model;
}
const auto dummy_test_model_all_inputs_as_internal_3 = TestModelManager::get().add("space_to_batch_quant8_signed_all_inputs_as_internal_3", get_test_model_all_inputs_as_internal_3());
} // namespace generated_tests::space_to_batch_quant8_signed
namespace generated_tests::space_to_batch_quant8_signed {
const TestModel& get_test_model_all_tensors_as_inputs_3() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {0, 1, 2},
.operands = {{ // input2
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-127, -126, -125, -124, -123, -122, -121, -120}),
.dimensions = {1, 4, 2, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 1.0f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}, { // block_size2
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({3, 2}),
.dimensions = {2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // paddings2
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({1, 1, 2, 4}),
.dimensions = {2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // output2
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-128, -128, -128, -128, -128, -123, -128, -128, -128, -128, -128, -128, -128, -122, -128, -128, -128, -127, -128, -128, -128, -121, -128, -128, -128, -126, -128, -128, -128, -120, -128, -128, -128, -125, -128, -128, -128, -128, -128, -128, -128, -124, -128, -128, -128, -128, -128, -128}),
.dimensions = {6, 2, 4, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 1.0f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}},
.operations = {{
.inputs = {0, 1, 2},
.outputs = {3},
.type = TestOperationType::SPACE_TO_BATCH_ND
}},
.outputIndexes = {3}
},
.minSupportedVersion = TestHalVersion::V1_3,
.referenced = {}
};
return model;
}
const auto dummy_test_model_all_tensors_as_inputs_3 = TestModelManager::get().add("space_to_batch_quant8_signed_all_tensors_as_inputs_3", get_test_model_all_tensors_as_inputs_3());
} // namespace generated_tests::space_to_batch_quant8_signed
namespace generated_tests::space_to_batch_quant8_signed {
const TestModel& get_test_model_all_tensors_as_inputs_all_inputs_as_internal_3() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {1, 2, 4},
.operands = {{ // input2
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({}),
.dimensions = {1, 4, 2, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
.numberOfConsumers = 1,
.scale = 1.0f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}, { // block_size2
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({3, 2}),
.dimensions = {2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // paddings2
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({1, 1, 2, 4}),
.dimensions = {2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // output2
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-128, -128, -128, -128, -128, -123, -128, -128, -128, -128, -128, -128, -128, -122, -128, -128, -128, -127, -128, -128, -128, -121, -128, -128, -128, -126, -128, -128, -128, -120, -128, -128, -128, -125, -128, -128, -128, -128, -128, -128, -128, -124, -128, -128, -128, -128, -128, -128}),
.dimensions = {6, 2, 4, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 1.0f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}, { // input2_new
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-127, -126, -125, -124, -123, -122, -121, -120}),
.dimensions = {1, 4, 2, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 1.0f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}, { // placeholder5
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-128}),
.dimensions = {1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 1.0f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}, { // param9
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({0}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::INT32,
.zeroPoint = 0
}},
.operations = {{
.inputs = {4, 5, 6},
.outputs = {0},
.type = TestOperationType::ADD
}, {
.inputs = {0, 1, 2},
.outputs = {3},
.type = TestOperationType::SPACE_TO_BATCH_ND
}},
.outputIndexes = {3}
},
.minSupportedVersion = TestHalVersion::V1_3,
.referenced = {}
};
return model;
}
const auto dummy_test_model_all_tensors_as_inputs_all_inputs_as_internal_3 = TestModelManager::get().add("space_to_batch_quant8_signed_all_tensors_as_inputs_all_inputs_as_internal_3", get_test_model_all_tensors_as_inputs_all_inputs_as_internal_3());
} // namespace generated_tests::space_to_batch_quant8_signed
namespace generated_tests::space_to_batch_quant8_signed {
const TestModel& get_test_model_4() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {0},
.operands = {{ // input3
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-127, -126, -125, -124, -123, -122, -121, -120, -119, -118}),
.dimensions = {1, 5, 2, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 1.0f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -119
}, { // block_size3
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({3, 2}),
.dimensions = {2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // paddings3
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({1, 0, 2, 0}),
.dimensions = {2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // output3
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-119, -119, -119, -123, -119, -119, -119, -122, -119, -127, -119, -121, -119, -126, -119, -120, -119, -125, -119, -119, -119, -124, -119, -118}),
.dimensions = {6, 2, 2, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 1.0f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -119
}},
.operations = {{
.inputs = {0, 1, 2},
.outputs = {3},
.type = TestOperationType::SPACE_TO_BATCH_ND
}},
.outputIndexes = {3}
},
.minSupportedVersion = TestHalVersion::V1_3,
.referenced = {}
};
return model;
}
const auto dummy_test_model_4 = TestModelManager::get().add("space_to_batch_quant8_signed_4", get_test_model_4());
} // namespace generated_tests::space_to_batch_quant8_signed
namespace generated_tests::space_to_batch_quant8_signed {
const TestModel& get_test_model_all_inputs_as_internal_4() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {4},
.operands = {{ // input3
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({}),
.dimensions = {1, 5, 2, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
.numberOfConsumers = 1,
.scale = 1.0f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -119
}, { // block_size3
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({3, 2}),
.dimensions = {2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // paddings3
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({1, 0, 2, 0}),
.dimensions = {2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // output3
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-119, -119, -119, -123, -119, -119, -119, -122, -119, -127, -119, -121, -119, -126, -119, -120, -119, -125, -119, -119, -119, -124, -119, -118}),
.dimensions = {6, 2, 2, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 1.0f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -119
}, { // input3_new
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-127, -126, -125, -124, -123, -122, -121, -120, -119, -118}),
.dimensions = {1, 5, 2, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 1.0f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -119
}, { // placeholder6
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-119}),
.dimensions = {1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 1.0f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -119
}, { // param10
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({0}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::INT32,
.zeroPoint = 0
}},
.operations = {{
.inputs = {4, 5, 6},
.outputs = {0},
.type = TestOperationType::ADD
}, {
.inputs = {0, 1, 2},
.outputs = {3},
.type = TestOperationType::SPACE_TO_BATCH_ND
}},
.outputIndexes = {3}
},
.minSupportedVersion = TestHalVersion::V1_3,
.referenced = {}
};
return model;
}
const auto dummy_test_model_all_inputs_as_internal_4 = TestModelManager::get().add("space_to_batch_quant8_signed_all_inputs_as_internal_4", get_test_model_all_inputs_as_internal_4());
} // namespace generated_tests::space_to_batch_quant8_signed
namespace generated_tests::space_to_batch_quant8_signed {
const TestModel& get_test_model_all_tensors_as_inputs_4() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {0, 1, 2},
.operands = {{ // input3
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-127, -126, -125, -124, -123, -122, -121, -120, -119, -118}),
.dimensions = {1, 5, 2, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 1.0f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -119
}, { // block_size3
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({3, 2}),
.dimensions = {2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // paddings3
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({1, 0, 2, 0}),
.dimensions = {2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // output3
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-119, -119, -119, -123, -119, -119, -119, -122, -119, -127, -119, -121, -119, -126, -119, -120, -119, -125, -119, -119, -119, -124, -119, -118}),
.dimensions = {6, 2, 2, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 1.0f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -119
}},
.operations = {{
.inputs = {0, 1, 2},
.outputs = {3},
.type = TestOperationType::SPACE_TO_BATCH_ND
}},
.outputIndexes = {3}
},
.minSupportedVersion = TestHalVersion::V1_3,
.referenced = {}
};
return model;
}
const auto dummy_test_model_all_tensors_as_inputs_4 = TestModelManager::get().add("space_to_batch_quant8_signed_all_tensors_as_inputs_4", get_test_model_all_tensors_as_inputs_4());
} // namespace generated_tests::space_to_batch_quant8_signed
namespace generated_tests::space_to_batch_quant8_signed {
const TestModel& get_test_model_all_tensors_as_inputs_all_inputs_as_internal_4() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {1, 2, 4},
.operands = {{ // input3
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({}),
.dimensions = {1, 5, 2, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
.numberOfConsumers = 1,
.scale = 1.0f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -119
}, { // block_size3
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({3, 2}),
.dimensions = {2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // paddings3
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({1, 0, 2, 0}),
.dimensions = {2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // output3
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-119, -119, -119, -123, -119, -119, -119, -122, -119, -127, -119, -121, -119, -126, -119, -120, -119, -125, -119, -119, -119, -124, -119, -118}),
.dimensions = {6, 2, 2, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 1.0f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -119
}, { // input3_new
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-127, -126, -125, -124, -123, -122, -121, -120, -119, -118}),
.dimensions = {1, 5, 2, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 1.0f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -119
}, { // placeholder7
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-119}),
.dimensions = {1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 1.0f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -119
}, { // param11
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({0}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::INT32,
.zeroPoint = 0
}},
.operations = {{
.inputs = {4, 5, 6},
.outputs = {0},
.type = TestOperationType::ADD
}, {
.inputs = {0, 1, 2},
.outputs = {3},
.type = TestOperationType::SPACE_TO_BATCH_ND
}},
.outputIndexes = {3}
},
.minSupportedVersion = TestHalVersion::V1_3,
.referenced = {}
};
return model;
}
const auto dummy_test_model_all_tensors_as_inputs_all_inputs_as_internal_4 = TestModelManager::get().add("space_to_batch_quant8_signed_all_tensors_as_inputs_all_inputs_as_internal_4", get_test_model_all_tensors_as_inputs_all_inputs_as_internal_4());
} // namespace generated_tests::space_to_batch_quant8_signed
namespace generated_tests::space_to_batch_quant8_signed {
const TestModel& get_test_model_nhwc_quant8_signed() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {0},
.operands = {{ // op1
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-114, -105, -96, -87, -74, -65, -56, -47}),
.dimensions = {1, 2, 2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.1f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}, { // param
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({2, 2}),
.dimensions = {2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // paddings4
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({0, 0, 0, 0}),
.dimensions = {2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // layout
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({false}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // op4
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-114, -105, -96, -87, -74, -65, -56, -47}),
.dimensions = {4, 1, 1, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.1f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}},
.operations = {{
.inputs = {0, 1, 2, 3},
.outputs = {4},
.type = TestOperationType::SPACE_TO_BATCH_ND
}},
.outputIndexes = {4}
},
.minSupportedVersion = TestHalVersion::V1_3,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nhwc_quant8_signed = TestModelManager::get().add("space_to_batch_quant8_signed_nhwc_quant8_signed", get_test_model_nhwc_quant8_signed());
} // namespace generated_tests::space_to_batch_quant8_signed
namespace generated_tests::space_to_batch_quant8_signed {
const TestModel& get_test_model_nhwc_quant8_signed_all_inputs_as_internal() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {5},
.operands = {{ // op1
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({}),
.dimensions = {1, 2, 2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
.numberOfConsumers = 1,
.scale = 0.1f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}, { // param
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({2, 2}),
.dimensions = {2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // paddings4
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({0, 0, 0, 0}),
.dimensions = {2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // layout
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({false}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // op4
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-114, -105, -96, -87, -74, -65, -56, -47}),
.dimensions = {4, 1, 1, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.1f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}, { // op1_new
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-114, -105, -96, -87, -74, -65, -56, -47}),
.dimensions = {1, 2, 2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.1f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}, { // placeholder8
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-128}),
.dimensions = {1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.1f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}, { // param12
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({0}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::INT32,
.zeroPoint = 0
}},
.operations = {{
.inputs = {5, 6, 7},
.outputs = {0},
.type = TestOperationType::ADD
}, {
.inputs = {0, 1, 2, 3},
.outputs = {4},
.type = TestOperationType::SPACE_TO_BATCH_ND
}},
.outputIndexes = {4}
},
.minSupportedVersion = TestHalVersion::V1_3,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nhwc_quant8_signed_all_inputs_as_internal = TestModelManager::get().add("space_to_batch_quant8_signed_nhwc_quant8_signed_all_inputs_as_internal", get_test_model_nhwc_quant8_signed_all_inputs_as_internal());
} // namespace generated_tests::space_to_batch_quant8_signed
namespace generated_tests::space_to_batch_quant8_signed {
const TestModel& get_test_model_nhwc_quant8_signed_all_tensors_as_inputs() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {0, 2},
.operands = {{ // op1
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-114, -105, -96, -87, -74, -65, -56, -47}),
.dimensions = {1, 2, 2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.1f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}, { // param
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({2, 2}),
.dimensions = {2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // paddings4
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({0, 0, 0, 0}),
.dimensions = {2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // layout
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({false}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // op4
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-114, -105, -96, -87, -74, -65, -56, -47}),
.dimensions = {4, 1, 1, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.1f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}},
.operations = {{
.inputs = {0, 1, 2, 3},
.outputs = {4},
.type = TestOperationType::SPACE_TO_BATCH_ND
}},
.outputIndexes = {4}
},
.minSupportedVersion = TestHalVersion::V1_3,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nhwc_quant8_signed_all_tensors_as_inputs = TestModelManager::get().add("space_to_batch_quant8_signed_nhwc_quant8_signed_all_tensors_as_inputs", get_test_model_nhwc_quant8_signed_all_tensors_as_inputs());
} // namespace generated_tests::space_to_batch_quant8_signed
namespace generated_tests::space_to_batch_quant8_signed {
const TestModel& get_test_model_nhwc_quant8_signed_all_tensors_as_inputs_all_inputs_as_internal() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {2, 5},
.operands = {{ // op1
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({}),
.dimensions = {1, 2, 2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
.numberOfConsumers = 1,
.scale = 0.1f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}, { // param
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({2, 2}),
.dimensions = {2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // paddings4
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({0, 0, 0, 0}),
.dimensions = {2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // layout
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({false}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // op4
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-114, -105, -96, -87, -74, -65, -56, -47}),
.dimensions = {4, 1, 1, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.1f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}, { // op1_new
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-114, -105, -96, -87, -74, -65, -56, -47}),
.dimensions = {1, 2, 2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.1f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}, { // placeholder9
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-128}),
.dimensions = {1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.1f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}, { // param13
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({0}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::INT32,
.zeroPoint = 0
}},
.operations = {{
.inputs = {5, 6, 7},
.outputs = {0},
.type = TestOperationType::ADD
}, {
.inputs = {0, 1, 2, 3},
.outputs = {4},
.type = TestOperationType::SPACE_TO_BATCH_ND
}},
.outputIndexes = {4}
},
.minSupportedVersion = TestHalVersion::V1_3,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nhwc_quant8_signed_all_tensors_as_inputs_all_inputs_as_internal = TestModelManager::get().add("space_to_batch_quant8_signed_nhwc_quant8_signed_all_tensors_as_inputs_all_inputs_as_internal", get_test_model_nhwc_quant8_signed_all_tensors_as_inputs_all_inputs_as_internal());
} // namespace generated_tests::space_to_batch_quant8_signed
namespace generated_tests::space_to_batch_quant8_signed {
const TestModel& get_test_model_nchw_quant8_signed() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {0},
.operands = {{ // op1
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-114, -96, -74, -56, -105, -87, -65, -47}),
.dimensions = {1, 2, 2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.1f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}, { // param
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({2, 2}),
.dimensions = {2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // paddings4
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({0, 0, 0, 0}),
.dimensions = {2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // layout
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({true}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // op4
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-114, -105, -96, -87, -74, -65, -56, -47}),
.dimensions = {4, 2, 1, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.1f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}},
.operations = {{
.inputs = {0, 1, 2, 3},
.outputs = {4},
.type = TestOperationType::SPACE_TO_BATCH_ND
}},
.outputIndexes = {4}
},
.minSupportedVersion = TestHalVersion::V1_3,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nchw_quant8_signed = TestModelManager::get().add("space_to_batch_quant8_signed_nchw_quant8_signed", get_test_model_nchw_quant8_signed());
} // namespace generated_tests::space_to_batch_quant8_signed
namespace generated_tests::space_to_batch_quant8_signed {
const TestModel& get_test_model_nchw_quant8_signed_all_inputs_as_internal() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {5},
.operands = {{ // op1
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({}),
.dimensions = {1, 2, 2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
.numberOfConsumers = 1,
.scale = 0.1f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}, { // param
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({2, 2}),
.dimensions = {2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // paddings4
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({0, 0, 0, 0}),
.dimensions = {2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // layout
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({true}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // op4
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-114, -105, -96, -87, -74, -65, -56, -47}),
.dimensions = {4, 2, 1, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.1f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}, { // op1_new
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-114, -96, -74, -56, -105, -87, -65, -47}),
.dimensions = {1, 2, 2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.1f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}, { // placeholder10
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-128}),
.dimensions = {1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.1f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}, { // param14
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({0}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::INT32,
.zeroPoint = 0
}},
.operations = {{
.inputs = {5, 6, 7},
.outputs = {0},
.type = TestOperationType::ADD
}, {
.inputs = {0, 1, 2, 3},
.outputs = {4},
.type = TestOperationType::SPACE_TO_BATCH_ND
}},
.outputIndexes = {4}
},
.minSupportedVersion = TestHalVersion::V1_3,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nchw_quant8_signed_all_inputs_as_internal = TestModelManager::get().add("space_to_batch_quant8_signed_nchw_quant8_signed_all_inputs_as_internal", get_test_model_nchw_quant8_signed_all_inputs_as_internal());
} // namespace generated_tests::space_to_batch_quant8_signed
namespace generated_tests::space_to_batch_quant8_signed {
const TestModel& get_test_model_nchw_quant8_signed_all_tensors_as_inputs() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {0, 2},
.operands = {{ // op1
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-114, -96, -74, -56, -105, -87, -65, -47}),
.dimensions = {1, 2, 2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.1f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}, { // param
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({2, 2}),
.dimensions = {2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // paddings4
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({0, 0, 0, 0}),
.dimensions = {2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // layout
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({true}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // op4
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-114, -105, -96, -87, -74, -65, -56, -47}),
.dimensions = {4, 2, 1, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.1f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}},
.operations = {{
.inputs = {0, 1, 2, 3},
.outputs = {4},
.type = TestOperationType::SPACE_TO_BATCH_ND
}},
.outputIndexes = {4}
},
.minSupportedVersion = TestHalVersion::V1_3,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nchw_quant8_signed_all_tensors_as_inputs = TestModelManager::get().add("space_to_batch_quant8_signed_nchw_quant8_signed_all_tensors_as_inputs", get_test_model_nchw_quant8_signed_all_tensors_as_inputs());
} // namespace generated_tests::space_to_batch_quant8_signed
namespace generated_tests::space_to_batch_quant8_signed {
const TestModel& get_test_model_nchw_quant8_signed_all_tensors_as_inputs_all_inputs_as_internal() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {2, 5},
.operands = {{ // op1
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({}),
.dimensions = {1, 2, 2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
.numberOfConsumers = 1,
.scale = 0.1f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}, { // param
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({2, 2}),
.dimensions = {2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // paddings4
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({0, 0, 0, 0}),
.dimensions = {2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // layout
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({true}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // op4
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-114, -105, -96, -87, -74, -65, -56, -47}),
.dimensions = {4, 2, 1, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.1f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}, { // op1_new
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-114, -96, -74, -56, -105, -87, -65, -47}),
.dimensions = {1, 2, 2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.1f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}, { // placeholder11
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-128}),
.dimensions = {1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.1f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}, { // param15
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({0}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::INT32,
.zeroPoint = 0
}},
.operations = {{
.inputs = {5, 6, 7},
.outputs = {0},
.type = TestOperationType::ADD
}, {
.inputs = {0, 1, 2, 3},
.outputs = {4},
.type = TestOperationType::SPACE_TO_BATCH_ND
}},
.outputIndexes = {4}
},
.minSupportedVersion = TestHalVersion::V1_3,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nchw_quant8_signed_all_tensors_as_inputs_all_inputs_as_internal = TestModelManager::get().add("space_to_batch_quant8_signed_nchw_quant8_signed_all_tensors_as_inputs_all_inputs_as_internal", get_test_model_nchw_quant8_signed_all_tensors_as_inputs_all_inputs_as_internal());
} // namespace generated_tests::space_to_batch_quant8_signed
namespace generated_tests::space_to_batch_quant8_signed {
const TestModel& get_test_model_nhwc_quant8_signed_2() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {0},
.operands = {{ // op11
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-126, -124, -122, -120, -118, -116, -114, -112, -110, -108, -106, -104, -102, -100, -98, -96}),
.dimensions = {1, 4, 4, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.5f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}, { // param1
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({2, 2}),
.dimensions = {2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // paddings4
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({0, 0, 0, 0}),
.dimensions = {2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // layout
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({false}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // op41
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-126, -122, -110, -106, -124, -120, -108, -104, -118, -114, -102, -98, -116, -112, -100, -96}),
.dimensions = {4, 2, 2, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.5f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}},
.operations = {{
.inputs = {0, 1, 2, 3},
.outputs = {4},
.type = TestOperationType::SPACE_TO_BATCH_ND
}},
.outputIndexes = {4}
},
.minSupportedVersion = TestHalVersion::V1_3,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nhwc_quant8_signed_2 = TestModelManager::get().add("space_to_batch_quant8_signed_nhwc_quant8_signed_2", get_test_model_nhwc_quant8_signed_2());
} // namespace generated_tests::space_to_batch_quant8_signed
namespace generated_tests::space_to_batch_quant8_signed {
const TestModel& get_test_model_nhwc_quant8_signed_all_inputs_as_internal_2() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {5},
.operands = {{ // op11
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({}),
.dimensions = {1, 4, 4, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
.numberOfConsumers = 1,
.scale = 0.5f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}, { // param1
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({2, 2}),
.dimensions = {2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // paddings4
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({0, 0, 0, 0}),
.dimensions = {2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // layout
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({false}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // op41
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-126, -122, -110, -106, -124, -120, -108, -104, -118, -114, -102, -98, -116, -112, -100, -96}),
.dimensions = {4, 2, 2, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.5f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}, { // op11_new
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-126, -124, -122, -120, -118, -116, -114, -112, -110, -108, -106, -104, -102, -100, -98, -96}),
.dimensions = {1, 4, 4, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.5f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}, { // placeholder12
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-128}),
.dimensions = {1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.5f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}, { // param16
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({0}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::INT32,
.zeroPoint = 0
}},
.operations = {{
.inputs = {5, 6, 7},
.outputs = {0},
.type = TestOperationType::ADD
}, {
.inputs = {0, 1, 2, 3},
.outputs = {4},
.type = TestOperationType::SPACE_TO_BATCH_ND
}},
.outputIndexes = {4}
},
.minSupportedVersion = TestHalVersion::V1_3,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nhwc_quant8_signed_all_inputs_as_internal_2 = TestModelManager::get().add("space_to_batch_quant8_signed_nhwc_quant8_signed_all_inputs_as_internal_2", get_test_model_nhwc_quant8_signed_all_inputs_as_internal_2());
} // namespace generated_tests::space_to_batch_quant8_signed
namespace generated_tests::space_to_batch_quant8_signed {
const TestModel& get_test_model_nhwc_quant8_signed_all_tensors_as_inputs_2() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {0, 2},
.operands = {{ // op11
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-126, -124, -122, -120, -118, -116, -114, -112, -110, -108, -106, -104, -102, -100, -98, -96}),
.dimensions = {1, 4, 4, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.5f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}, { // param1
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({2, 2}),
.dimensions = {2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // paddings4
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({0, 0, 0, 0}),
.dimensions = {2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // layout
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({false}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // op41
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-126, -122, -110, -106, -124, -120, -108, -104, -118, -114, -102, -98, -116, -112, -100, -96}),
.dimensions = {4, 2, 2, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.5f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}},
.operations = {{
.inputs = {0, 1, 2, 3},
.outputs = {4},
.type = TestOperationType::SPACE_TO_BATCH_ND
}},
.outputIndexes = {4}
},
.minSupportedVersion = TestHalVersion::V1_3,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nhwc_quant8_signed_all_tensors_as_inputs_2 = TestModelManager::get().add("space_to_batch_quant8_signed_nhwc_quant8_signed_all_tensors_as_inputs_2", get_test_model_nhwc_quant8_signed_all_tensors_as_inputs_2());
} // namespace generated_tests::space_to_batch_quant8_signed
namespace generated_tests::space_to_batch_quant8_signed {
const TestModel& get_test_model_nhwc_quant8_signed_all_tensors_as_inputs_all_inputs_as_internal_2() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {2, 5},
.operands = {{ // op11
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({}),
.dimensions = {1, 4, 4, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
.numberOfConsumers = 1,
.scale = 0.5f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}, { // param1
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({2, 2}),
.dimensions = {2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // paddings4
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({0, 0, 0, 0}),
.dimensions = {2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // layout
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({false}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // op41
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-126, -122, -110, -106, -124, -120, -108, -104, -118, -114, -102, -98, -116, -112, -100, -96}),
.dimensions = {4, 2, 2, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.5f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}, { // op11_new
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-126, -124, -122, -120, -118, -116, -114, -112, -110, -108, -106, -104, -102, -100, -98, -96}),
.dimensions = {1, 4, 4, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.5f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}, { // placeholder13
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-128}),
.dimensions = {1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.5f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}, { // param17
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({0}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::INT32,
.zeroPoint = 0
}},
.operations = {{
.inputs = {5, 6, 7},
.outputs = {0},
.type = TestOperationType::ADD
}, {
.inputs = {0, 1, 2, 3},
.outputs = {4},
.type = TestOperationType::SPACE_TO_BATCH_ND
}},
.outputIndexes = {4}
},
.minSupportedVersion = TestHalVersion::V1_3,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nhwc_quant8_signed_all_tensors_as_inputs_all_inputs_as_internal_2 = TestModelManager::get().add("space_to_batch_quant8_signed_nhwc_quant8_signed_all_tensors_as_inputs_all_inputs_as_internal_2", get_test_model_nhwc_quant8_signed_all_tensors_as_inputs_all_inputs_as_internal_2());
} // namespace generated_tests::space_to_batch_quant8_signed
namespace generated_tests::space_to_batch_quant8_signed {
const TestModel& get_test_model_nchw_quant8_signed_2() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {0},
.operands = {{ // op11
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-126, -124, -122, -120, -118, -116, -114, -112, -110, -108, -106, -104, -102, -100, -98, -96}),
.dimensions = {1, 1, 4, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.5f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}, { // param1
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({2, 2}),
.dimensions = {2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // paddings4
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({0, 0, 0, 0}),
.dimensions = {2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // layout
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({true}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // op41
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-126, -122, -110, -106, -124, -120, -108, -104, -118, -114, -102, -98, -116, -112, -100, -96}),
.dimensions = {4, 1, 2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.5f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}},
.operations = {{
.inputs = {0, 1, 2, 3},
.outputs = {4},
.type = TestOperationType::SPACE_TO_BATCH_ND
}},
.outputIndexes = {4}
},
.minSupportedVersion = TestHalVersion::V1_3,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nchw_quant8_signed_2 = TestModelManager::get().add("space_to_batch_quant8_signed_nchw_quant8_signed_2", get_test_model_nchw_quant8_signed_2());
} // namespace generated_tests::space_to_batch_quant8_signed
namespace generated_tests::space_to_batch_quant8_signed {
const TestModel& get_test_model_nchw_quant8_signed_all_inputs_as_internal_2() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {5},
.operands = {{ // op11
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({}),
.dimensions = {1, 1, 4, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
.numberOfConsumers = 1,
.scale = 0.5f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}, { // param1
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({2, 2}),
.dimensions = {2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // paddings4
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({0, 0, 0, 0}),
.dimensions = {2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // layout
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({true}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // op41
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-126, -122, -110, -106, -124, -120, -108, -104, -118, -114, -102, -98, -116, -112, -100, -96}),
.dimensions = {4, 1, 2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.5f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}, { // op11_new
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-126, -124, -122, -120, -118, -116, -114, -112, -110, -108, -106, -104, -102, -100, -98, -96}),
.dimensions = {1, 1, 4, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.5f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}, { // placeholder14
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-128}),
.dimensions = {1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.5f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}, { // param18
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({0}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::INT32,
.zeroPoint = 0
}},
.operations = {{
.inputs = {5, 6, 7},
.outputs = {0},
.type = TestOperationType::ADD
}, {
.inputs = {0, 1, 2, 3},
.outputs = {4},
.type = TestOperationType::SPACE_TO_BATCH_ND
}},
.outputIndexes = {4}
},
.minSupportedVersion = TestHalVersion::V1_3,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nchw_quant8_signed_all_inputs_as_internal_2 = TestModelManager::get().add("space_to_batch_quant8_signed_nchw_quant8_signed_all_inputs_as_internal_2", get_test_model_nchw_quant8_signed_all_inputs_as_internal_2());
} // namespace generated_tests::space_to_batch_quant8_signed
namespace generated_tests::space_to_batch_quant8_signed {
const TestModel& get_test_model_nchw_quant8_signed_all_tensors_as_inputs_2() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {0, 2},
.operands = {{ // op11
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-126, -124, -122, -120, -118, -116, -114, -112, -110, -108, -106, -104, -102, -100, -98, -96}),
.dimensions = {1, 1, 4, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.5f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}, { // param1
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({2, 2}),
.dimensions = {2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // paddings4
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({0, 0, 0, 0}),
.dimensions = {2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // layout
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({true}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // op41
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-126, -122, -110, -106, -124, -120, -108, -104, -118, -114, -102, -98, -116, -112, -100, -96}),
.dimensions = {4, 1, 2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.5f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}},
.operations = {{
.inputs = {0, 1, 2, 3},
.outputs = {4},
.type = TestOperationType::SPACE_TO_BATCH_ND
}},
.outputIndexes = {4}
},
.minSupportedVersion = TestHalVersion::V1_3,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nchw_quant8_signed_all_tensors_as_inputs_2 = TestModelManager::get().add("space_to_batch_quant8_signed_nchw_quant8_signed_all_tensors_as_inputs_2", get_test_model_nchw_quant8_signed_all_tensors_as_inputs_2());
} // namespace generated_tests::space_to_batch_quant8_signed
namespace generated_tests::space_to_batch_quant8_signed {
const TestModel& get_test_model_nchw_quant8_signed_all_tensors_as_inputs_all_inputs_as_internal_2() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {2, 5},
.operands = {{ // op11
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({}),
.dimensions = {1, 1, 4, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
.numberOfConsumers = 1,
.scale = 0.5f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}, { // param1
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({2, 2}),
.dimensions = {2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // paddings4
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({0, 0, 0, 0}),
.dimensions = {2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // layout
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({true}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // op41
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-126, -122, -110, -106, -124, -120, -108, -104, -118, -114, -102, -98, -116, -112, -100, -96}),
.dimensions = {4, 1, 2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.5f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}, { // op11_new
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-126, -124, -122, -120, -118, -116, -114, -112, -110, -108, -106, -104, -102, -100, -98, -96}),
.dimensions = {1, 1, 4, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.5f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}, { // placeholder15
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({-128}),
.dimensions = {1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.5f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = -128
}, { // param19
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({0}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::INT32,
.zeroPoint = 0
}},
.operations = {{
.inputs = {5, 6, 7},
.outputs = {0},
.type = TestOperationType::ADD
}, {
.inputs = {0, 1, 2, 3},
.outputs = {4},
.type = TestOperationType::SPACE_TO_BATCH_ND
}},
.outputIndexes = {4}
},
.minSupportedVersion = TestHalVersion::V1_3,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nchw_quant8_signed_all_tensors_as_inputs_all_inputs_as_internal_2 = TestModelManager::get().add("space_to_batch_quant8_signed_nchw_quant8_signed_all_tensors_as_inputs_all_inputs_as_internal_2", get_test_model_nchw_quant8_signed_all_tensors_as_inputs_all_inputs_as_internal_2());
} // namespace generated_tests::space_to_batch_quant8_signed
namespace generated_tests::space_to_batch_quant8_signed {
const TestModel& get_test_model_nhwc_quant8_signed_3() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {0},
.operands = {{ // op12
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({2, 4, 6, 8, 10, 12, 14, 16, 18, 20}),
.dimensions = {1, 5, 2, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.5f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = 0
}, { // param2
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({3, 2}),
.dimensions = {2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // paddings5
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({1, 0, 2, 0}),
.dimensions = {2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // layout
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({false}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // op42
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({0, 0, 0, 10, 0, 0, 0, 12, 0, 2, 0, 14, 0, 4, 0, 16, 0, 6, 0, 18, 0, 8, 0, 20}),
.dimensions = {6, 2, 2, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.5f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = 0
}},
.operations = {{
.inputs = {0, 1, 2, 3},
.outputs = {4},
.type = TestOperationType::SPACE_TO_BATCH_ND
}},
.outputIndexes = {4}
},
.minSupportedVersion = TestHalVersion::V1_3,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nhwc_quant8_signed_3 = TestModelManager::get().add("space_to_batch_quant8_signed_nhwc_quant8_signed_3", get_test_model_nhwc_quant8_signed_3());
} // namespace generated_tests::space_to_batch_quant8_signed
namespace generated_tests::space_to_batch_quant8_signed {
const TestModel& get_test_model_nhwc_quant8_signed_all_inputs_as_internal_3() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {5},
.operands = {{ // op12
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({}),
.dimensions = {1, 5, 2, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
.numberOfConsumers = 1,
.scale = 0.5f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = 0
}, { // param2
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({3, 2}),
.dimensions = {2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // paddings5
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({1, 0, 2, 0}),
.dimensions = {2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // layout
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({false}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // op42
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({0, 0, 0, 10, 0, 0, 0, 12, 0, 2, 0, 14, 0, 4, 0, 16, 0, 6, 0, 18, 0, 8, 0, 20}),
.dimensions = {6, 2, 2, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.5f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = 0
}, { // op12_new
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({2, 4, 6, 8, 10, 12, 14, 16, 18, 20}),
.dimensions = {1, 5, 2, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.5f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = 0
}, { // placeholder16
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({0}),
.dimensions = {1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.5f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = 0
}, { // param20
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({0}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::INT32,
.zeroPoint = 0
}},
.operations = {{
.inputs = {5, 6, 7},
.outputs = {0},
.type = TestOperationType::ADD
}, {
.inputs = {0, 1, 2, 3},
.outputs = {4},
.type = TestOperationType::SPACE_TO_BATCH_ND
}},
.outputIndexes = {4}
},
.minSupportedVersion = TestHalVersion::V1_3,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nhwc_quant8_signed_all_inputs_as_internal_3 = TestModelManager::get().add("space_to_batch_quant8_signed_nhwc_quant8_signed_all_inputs_as_internal_3", get_test_model_nhwc_quant8_signed_all_inputs_as_internal_3());
} // namespace generated_tests::space_to_batch_quant8_signed
namespace generated_tests::space_to_batch_quant8_signed {
const TestModel& get_test_model_nhwc_quant8_signed_all_tensors_as_inputs_3() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {0, 2},
.operands = {{ // op12
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({2, 4, 6, 8, 10, 12, 14, 16, 18, 20}),
.dimensions = {1, 5, 2, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.5f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = 0
}, { // param2
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({3, 2}),
.dimensions = {2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // paddings5
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({1, 0, 2, 0}),
.dimensions = {2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // layout
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({false}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // op42
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({0, 0, 0, 10, 0, 0, 0, 12, 0, 2, 0, 14, 0, 4, 0, 16, 0, 6, 0, 18, 0, 8, 0, 20}),
.dimensions = {6, 2, 2, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.5f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = 0
}},
.operations = {{
.inputs = {0, 1, 2, 3},
.outputs = {4},
.type = TestOperationType::SPACE_TO_BATCH_ND
}},
.outputIndexes = {4}
},
.minSupportedVersion = TestHalVersion::V1_3,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nhwc_quant8_signed_all_tensors_as_inputs_3 = TestModelManager::get().add("space_to_batch_quant8_signed_nhwc_quant8_signed_all_tensors_as_inputs_3", get_test_model_nhwc_quant8_signed_all_tensors_as_inputs_3());
} // namespace generated_tests::space_to_batch_quant8_signed
namespace generated_tests::space_to_batch_quant8_signed {
const TestModel& get_test_model_nhwc_quant8_signed_all_tensors_as_inputs_all_inputs_as_internal_3() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {2, 5},
.operands = {{ // op12
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({}),
.dimensions = {1, 5, 2, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
.numberOfConsumers = 1,
.scale = 0.5f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = 0
}, { // param2
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({3, 2}),
.dimensions = {2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // paddings5
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({1, 0, 2, 0}),
.dimensions = {2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // layout
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({false}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // op42
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({0, 0, 0, 10, 0, 0, 0, 12, 0, 2, 0, 14, 0, 4, 0, 16, 0, 6, 0, 18, 0, 8, 0, 20}),
.dimensions = {6, 2, 2, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.5f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = 0
}, { // op12_new
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({2, 4, 6, 8, 10, 12, 14, 16, 18, 20}),
.dimensions = {1, 5, 2, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.5f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = 0
}, { // placeholder17
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({0}),
.dimensions = {1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.5f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = 0
}, { // param21
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({0}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::INT32,
.zeroPoint = 0
}},
.operations = {{
.inputs = {5, 6, 7},
.outputs = {0},
.type = TestOperationType::ADD
}, {
.inputs = {0, 1, 2, 3},
.outputs = {4},
.type = TestOperationType::SPACE_TO_BATCH_ND
}},
.outputIndexes = {4}
},
.minSupportedVersion = TestHalVersion::V1_3,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nhwc_quant8_signed_all_tensors_as_inputs_all_inputs_as_internal_3 = TestModelManager::get().add("space_to_batch_quant8_signed_nhwc_quant8_signed_all_tensors_as_inputs_all_inputs_as_internal_3", get_test_model_nhwc_quant8_signed_all_tensors_as_inputs_all_inputs_as_internal_3());
} // namespace generated_tests::space_to_batch_quant8_signed
namespace generated_tests::space_to_batch_quant8_signed {
const TestModel& get_test_model_nchw_quant8_signed_3() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {0},
.operands = {{ // op12
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({2, 4, 6, 8, 10, 12, 14, 16, 18, 20}),
.dimensions = {1, 1, 5, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.5f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = 0
}, { // param2
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({3, 2}),
.dimensions = {2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // paddings5
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({1, 0, 2, 0}),
.dimensions = {2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // layout
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({true}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // op42
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({0, 0, 0, 10, 0, 0, 0, 12, 0, 2, 0, 14, 0, 4, 0, 16, 0, 6, 0, 18, 0, 8, 0, 20}),
.dimensions = {6, 1, 2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.5f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = 0
}},
.operations = {{
.inputs = {0, 1, 2, 3},
.outputs = {4},
.type = TestOperationType::SPACE_TO_BATCH_ND
}},
.outputIndexes = {4}
},
.minSupportedVersion = TestHalVersion::V1_3,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nchw_quant8_signed_3 = TestModelManager::get().add("space_to_batch_quant8_signed_nchw_quant8_signed_3", get_test_model_nchw_quant8_signed_3());
} // namespace generated_tests::space_to_batch_quant8_signed
namespace generated_tests::space_to_batch_quant8_signed {
const TestModel& get_test_model_nchw_quant8_signed_all_inputs_as_internal_3() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {5},
.operands = {{ // op12
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({}),
.dimensions = {1, 1, 5, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
.numberOfConsumers = 1,
.scale = 0.5f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = 0
}, { // param2
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({3, 2}),
.dimensions = {2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // paddings5
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({1, 0, 2, 0}),
.dimensions = {2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // layout
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({true}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // op42
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({0, 0, 0, 10, 0, 0, 0, 12, 0, 2, 0, 14, 0, 4, 0, 16, 0, 6, 0, 18, 0, 8, 0, 20}),
.dimensions = {6, 1, 2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.5f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = 0
}, { // op12_new
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({2, 4, 6, 8, 10, 12, 14, 16, 18, 20}),
.dimensions = {1, 1, 5, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.5f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = 0
}, { // placeholder18
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({0}),
.dimensions = {1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.5f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = 0
}, { // param22
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({0}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::INT32,
.zeroPoint = 0
}},
.operations = {{
.inputs = {5, 6, 7},
.outputs = {0},
.type = TestOperationType::ADD
}, {
.inputs = {0, 1, 2, 3},
.outputs = {4},
.type = TestOperationType::SPACE_TO_BATCH_ND
}},
.outputIndexes = {4}
},
.minSupportedVersion = TestHalVersion::V1_3,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nchw_quant8_signed_all_inputs_as_internal_3 = TestModelManager::get().add("space_to_batch_quant8_signed_nchw_quant8_signed_all_inputs_as_internal_3", get_test_model_nchw_quant8_signed_all_inputs_as_internal_3());
} // namespace generated_tests::space_to_batch_quant8_signed
namespace generated_tests::space_to_batch_quant8_signed {
const TestModel& get_test_model_nchw_quant8_signed_all_tensors_as_inputs_3() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {0, 2},
.operands = {{ // op12
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({2, 4, 6, 8, 10, 12, 14, 16, 18, 20}),
.dimensions = {1, 1, 5, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.5f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = 0
}, { // param2
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({3, 2}),
.dimensions = {2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // paddings5
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({1, 0, 2, 0}),
.dimensions = {2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // layout
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({true}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // op42
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({0, 0, 0, 10, 0, 0, 0, 12, 0, 2, 0, 14, 0, 4, 0, 16, 0, 6, 0, 18, 0, 8, 0, 20}),
.dimensions = {6, 1, 2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.5f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = 0
}},
.operations = {{
.inputs = {0, 1, 2, 3},
.outputs = {4},
.type = TestOperationType::SPACE_TO_BATCH_ND
}},
.outputIndexes = {4}
},
.minSupportedVersion = TestHalVersion::V1_3,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nchw_quant8_signed_all_tensors_as_inputs_3 = TestModelManager::get().add("space_to_batch_quant8_signed_nchw_quant8_signed_all_tensors_as_inputs_3", get_test_model_nchw_quant8_signed_all_tensors_as_inputs_3());
} // namespace generated_tests::space_to_batch_quant8_signed
namespace generated_tests::space_to_batch_quant8_signed {
const TestModel& get_test_model_nchw_quant8_signed_all_tensors_as_inputs_all_inputs_as_internal_3() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {2, 5},
.operands = {{ // op12
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({}),
.dimensions = {1, 1, 5, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
.numberOfConsumers = 1,
.scale = 0.5f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = 0
}, { // param2
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({3, 2}),
.dimensions = {2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // paddings5
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({1, 0, 2, 0}),
.dimensions = {2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // layout
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({true}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // op42
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({0, 0, 0, 10, 0, 0, 0, 12, 0, 2, 0, 14, 0, 4, 0, 16, 0, 6, 0, 18, 0, 8, 0, 20}),
.dimensions = {6, 1, 2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.5f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = 0
}, { // op12_new
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({2, 4, 6, 8, 10, 12, 14, 16, 18, 20}),
.dimensions = {1, 1, 5, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.5f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = 0
}, { // placeholder19
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({0}),
.dimensions = {1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.5f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = 0
}, { // param23
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({0}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::INT32,
.zeroPoint = 0
}},
.operations = {{
.inputs = {5, 6, 7},
.outputs = {0},
.type = TestOperationType::ADD
}, {
.inputs = {0, 1, 2, 3},
.outputs = {4},
.type = TestOperationType::SPACE_TO_BATCH_ND
}},
.outputIndexes = {4}
},
.minSupportedVersion = TestHalVersion::V1_3,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nchw_quant8_signed_all_tensors_as_inputs_all_inputs_as_internal_3 = TestModelManager::get().add("space_to_batch_quant8_signed_nchw_quant8_signed_all_tensors_as_inputs_all_inputs_as_internal_3", get_test_model_nchw_quant8_signed_all_tensors_as_inputs_all_inputs_as_internal_3());
} // namespace generated_tests::space_to_batch_quant8_signed
namespace generated_tests::space_to_batch_quant8_signed {
const TestModel& get_test_model_nhwc_quant8_signed_4() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {0},
.operands = {{ // op13
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({4, 8, 12, 16, 20, 24, 28, 32}),
.dimensions = {1, 4, 2, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.25f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = 0
}, { // param3
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({3, 2}),
.dimensions = {2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // paddings6
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({1, 1, 2, 4}),
.dimensions = {2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // layout
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({false}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // op43
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({0, 0, 0, 0, 0, 20, 0, 0, 0, 0, 0, 0, 0, 24, 0, 0, 0, 4, 0, 0, 0, 28, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 12, 0, 0, 0, 0, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0}),
.dimensions = {6, 2, 4, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.25f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = 0
}},
.operations = {{
.inputs = {0, 1, 2, 3},
.outputs = {4},
.type = TestOperationType::SPACE_TO_BATCH_ND
}},
.outputIndexes = {4}
},
.minSupportedVersion = TestHalVersion::V1_3,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nhwc_quant8_signed_4 = TestModelManager::get().add("space_to_batch_quant8_signed_nhwc_quant8_signed_4", get_test_model_nhwc_quant8_signed_4());
} // namespace generated_tests::space_to_batch_quant8_signed
namespace generated_tests::space_to_batch_quant8_signed {
const TestModel& get_test_model_nhwc_quant8_signed_all_inputs_as_internal_4() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {5},
.operands = {{ // op13
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({}),
.dimensions = {1, 4, 2, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
.numberOfConsumers = 1,
.scale = 0.25f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = 0
}, { // param3
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({3, 2}),
.dimensions = {2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // paddings6
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({1, 1, 2, 4}),
.dimensions = {2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // layout
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({false}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // op43
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({0, 0, 0, 0, 0, 20, 0, 0, 0, 0, 0, 0, 0, 24, 0, 0, 0, 4, 0, 0, 0, 28, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 12, 0, 0, 0, 0, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0}),
.dimensions = {6, 2, 4, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.25f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = 0
}, { // op13_new
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({4, 8, 12, 16, 20, 24, 28, 32}),
.dimensions = {1, 4, 2, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.25f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = 0
}, { // placeholder20
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({0}),
.dimensions = {1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.25f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = 0
}, { // param24
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({0}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::INT32,
.zeroPoint = 0
}},
.operations = {{
.inputs = {5, 6, 7},
.outputs = {0},
.type = TestOperationType::ADD
}, {
.inputs = {0, 1, 2, 3},
.outputs = {4},
.type = TestOperationType::SPACE_TO_BATCH_ND
}},
.outputIndexes = {4}
},
.minSupportedVersion = TestHalVersion::V1_3,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nhwc_quant8_signed_all_inputs_as_internal_4 = TestModelManager::get().add("space_to_batch_quant8_signed_nhwc_quant8_signed_all_inputs_as_internal_4", get_test_model_nhwc_quant8_signed_all_inputs_as_internal_4());
} // namespace generated_tests::space_to_batch_quant8_signed
namespace generated_tests::space_to_batch_quant8_signed {
const TestModel& get_test_model_nhwc_quant8_signed_all_tensors_as_inputs_4() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {0, 2},
.operands = {{ // op13
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({4, 8, 12, 16, 20, 24, 28, 32}),
.dimensions = {1, 4, 2, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.25f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = 0
}, { // param3
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({3, 2}),
.dimensions = {2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // paddings6
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({1, 1, 2, 4}),
.dimensions = {2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // layout
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({false}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // op43
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({0, 0, 0, 0, 0, 20, 0, 0, 0, 0, 0, 0, 0, 24, 0, 0, 0, 4, 0, 0, 0, 28, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 12, 0, 0, 0, 0, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0}),
.dimensions = {6, 2, 4, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.25f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = 0
}},
.operations = {{
.inputs = {0, 1, 2, 3},
.outputs = {4},
.type = TestOperationType::SPACE_TO_BATCH_ND
}},
.outputIndexes = {4}
},
.minSupportedVersion = TestHalVersion::V1_3,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nhwc_quant8_signed_all_tensors_as_inputs_4 = TestModelManager::get().add("space_to_batch_quant8_signed_nhwc_quant8_signed_all_tensors_as_inputs_4", get_test_model_nhwc_quant8_signed_all_tensors_as_inputs_4());
} // namespace generated_tests::space_to_batch_quant8_signed
namespace generated_tests::space_to_batch_quant8_signed {
const TestModel& get_test_model_nhwc_quant8_signed_all_tensors_as_inputs_all_inputs_as_internal_4() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {2, 5},
.operands = {{ // op13
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({}),
.dimensions = {1, 4, 2, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
.numberOfConsumers = 1,
.scale = 0.25f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = 0
}, { // param3
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({3, 2}),
.dimensions = {2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // paddings6
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({1, 1, 2, 4}),
.dimensions = {2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // layout
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({false}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // op43
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({0, 0, 0, 0, 0, 20, 0, 0, 0, 0, 0, 0, 0, 24, 0, 0, 0, 4, 0, 0, 0, 28, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 12, 0, 0, 0, 0, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0}),
.dimensions = {6, 2, 4, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.25f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = 0
}, { // op13_new
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({4, 8, 12, 16, 20, 24, 28, 32}),
.dimensions = {1, 4, 2, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.25f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = 0
}, { // placeholder21
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({0}),
.dimensions = {1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.25f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = 0
}, { // param25
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({0}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::INT32,
.zeroPoint = 0
}},
.operations = {{
.inputs = {5, 6, 7},
.outputs = {0},
.type = TestOperationType::ADD
}, {
.inputs = {0, 1, 2, 3},
.outputs = {4},
.type = TestOperationType::SPACE_TO_BATCH_ND
}},
.outputIndexes = {4}
},
.minSupportedVersion = TestHalVersion::V1_3,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nhwc_quant8_signed_all_tensors_as_inputs_all_inputs_as_internal_4 = TestModelManager::get().add("space_to_batch_quant8_signed_nhwc_quant8_signed_all_tensors_as_inputs_all_inputs_as_internal_4", get_test_model_nhwc_quant8_signed_all_tensors_as_inputs_all_inputs_as_internal_4());
} // namespace generated_tests::space_to_batch_quant8_signed
namespace generated_tests::space_to_batch_quant8_signed {
const TestModel& get_test_model_nchw_quant8_signed_4() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {0},
.operands = {{ // op13
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({4, 8, 12, 16, 20, 24, 28, 32}),
.dimensions = {1, 1, 4, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.25f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = 0
}, { // param3
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({3, 2}),
.dimensions = {2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // paddings6
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({1, 1, 2, 4}),
.dimensions = {2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // layout
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({true}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // op43
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({0, 0, 0, 0, 0, 20, 0, 0, 0, 0, 0, 0, 0, 24, 0, 0, 0, 4, 0, 0, 0, 28, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 12, 0, 0, 0, 0, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0}),
.dimensions = {6, 1, 2, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.25f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = 0
}},
.operations = {{
.inputs = {0, 1, 2, 3},
.outputs = {4},
.type = TestOperationType::SPACE_TO_BATCH_ND
}},
.outputIndexes = {4}
},
.minSupportedVersion = TestHalVersion::V1_3,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nchw_quant8_signed_4 = TestModelManager::get().add("space_to_batch_quant8_signed_nchw_quant8_signed_4", get_test_model_nchw_quant8_signed_4());
} // namespace generated_tests::space_to_batch_quant8_signed
namespace generated_tests::space_to_batch_quant8_signed {
const TestModel& get_test_model_nchw_quant8_signed_all_inputs_as_internal_4() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {5},
.operands = {{ // op13
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({}),
.dimensions = {1, 1, 4, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
.numberOfConsumers = 1,
.scale = 0.25f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = 0
}, { // param3
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({3, 2}),
.dimensions = {2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // paddings6
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({1, 1, 2, 4}),
.dimensions = {2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // layout
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({true}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // op43
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({0, 0, 0, 0, 0, 20, 0, 0, 0, 0, 0, 0, 0, 24, 0, 0, 0, 4, 0, 0, 0, 28, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 12, 0, 0, 0, 0, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0}),
.dimensions = {6, 1, 2, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.25f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = 0
}, { // op13_new
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({4, 8, 12, 16, 20, 24, 28, 32}),
.dimensions = {1, 1, 4, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.25f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = 0
}, { // placeholder22
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({0}),
.dimensions = {1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.25f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = 0
}, { // param26
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({0}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::INT32,
.zeroPoint = 0
}},
.operations = {{
.inputs = {5, 6, 7},
.outputs = {0},
.type = TestOperationType::ADD
}, {
.inputs = {0, 1, 2, 3},
.outputs = {4},
.type = TestOperationType::SPACE_TO_BATCH_ND
}},
.outputIndexes = {4}
},
.minSupportedVersion = TestHalVersion::V1_3,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nchw_quant8_signed_all_inputs_as_internal_4 = TestModelManager::get().add("space_to_batch_quant8_signed_nchw_quant8_signed_all_inputs_as_internal_4", get_test_model_nchw_quant8_signed_all_inputs_as_internal_4());
} // namespace generated_tests::space_to_batch_quant8_signed
namespace generated_tests::space_to_batch_quant8_signed {
const TestModel& get_test_model_nchw_quant8_signed_all_tensors_as_inputs_4() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {0, 2},
.operands = {{ // op13
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({4, 8, 12, 16, 20, 24, 28, 32}),
.dimensions = {1, 1, 4, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.25f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = 0
}, { // param3
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({3, 2}),
.dimensions = {2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // paddings6
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({1, 1, 2, 4}),
.dimensions = {2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // layout
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({true}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // op43
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({0, 0, 0, 0, 0, 20, 0, 0, 0, 0, 0, 0, 0, 24, 0, 0, 0, 4, 0, 0, 0, 28, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 12, 0, 0, 0, 0, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0}),
.dimensions = {6, 1, 2, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.25f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = 0
}},
.operations = {{
.inputs = {0, 1, 2, 3},
.outputs = {4},
.type = TestOperationType::SPACE_TO_BATCH_ND
}},
.outputIndexes = {4}
},
.minSupportedVersion = TestHalVersion::V1_3,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nchw_quant8_signed_all_tensors_as_inputs_4 = TestModelManager::get().add("space_to_batch_quant8_signed_nchw_quant8_signed_all_tensors_as_inputs_4", get_test_model_nchw_quant8_signed_all_tensors_as_inputs_4());
} // namespace generated_tests::space_to_batch_quant8_signed
namespace generated_tests::space_to_batch_quant8_signed {
const TestModel& get_test_model_nchw_quant8_signed_all_tensors_as_inputs_all_inputs_as_internal_4() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {2, 5},
.operands = {{ // op13
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({}),
.dimensions = {1, 1, 4, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
.numberOfConsumers = 1,
.scale = 0.25f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = 0
}, { // param3
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({3, 2}),
.dimensions = {2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // paddings6
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({1, 1, 2, 4}),
.dimensions = {2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_INT32,
.zeroPoint = 0
}, { // layout
.channelQuant = {},
.data = TestBuffer::createFromVector<bool8>({true}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::BOOL,
.zeroPoint = 0
}, { // op43
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({0, 0, 0, 0, 0, 20, 0, 0, 0, 0, 0, 0, 0, 24, 0, 0, 0, 4, 0, 0, 0, 28, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 12, 0, 0, 0, 0, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0}),
.dimensions = {6, 1, 2, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.25f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = 0
}, { // op13_new
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({4, 8, 12, 16, 20, 24, 28, 32}),
.dimensions = {1, 1, 4, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.25f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = 0
}, { // placeholder23
.channelQuant = {},
.data = TestBuffer::createFromVector<int8_t>({0}),
.dimensions = {1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.25f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM_SIGNED,
.zeroPoint = 0
}, { // param27
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({0}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::INT32,
.zeroPoint = 0
}},
.operations = {{
.inputs = {5, 6, 7},
.outputs = {0},
.type = TestOperationType::ADD
}, {
.inputs = {0, 1, 2, 3},
.outputs = {4},
.type = TestOperationType::SPACE_TO_BATCH_ND
}},
.outputIndexes = {4}
},
.minSupportedVersion = TestHalVersion::V1_3,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nchw_quant8_signed_all_tensors_as_inputs_all_inputs_as_internal_4 = TestModelManager::get().add("space_to_batch_quant8_signed_nchw_quant8_signed_all_tensors_as_inputs_all_inputs_as_internal_4", get_test_model_nchw_quant8_signed_all_tensors_as_inputs_all_inputs_as_internal_4());
} // namespace generated_tests::space_to_batch_quant8_signed