Google Git
Sign in
android / platform / frameworks / ml / a6c9aae8bbc8fb25f63d7fae6262bd63668375a9 / . / nn / runtime / test / generated / spec_V1_2 / depth_to_space_v1_2.example.cpp
blob: dde80b4bac6f102354c530e93ff6f98ca1359d2a [file] [log] [blame]
// Generated from depth_to_space_v1_2.mod.py
// DO NOT EDIT
// clang-format off
#include "TestHarness.h"
using namespace test_helper;
namespace generated_tests::depth_to_space_v1_2 {
const TestModel& get_test_model_nhwc() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {0},
.operands = {{ // op1
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({1.4f, 2.3f, 3.2f, 4.1f, 5.4f, 6.3f, 7.2f, 8.1f}),
.dimensions = {1, 1, 1, 8},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // param
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({2}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::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<float>({1.4f, 2.3f, 3.2f, 4.1f, 5.4f, 6.3f, 7.2f, 8.1f}),
.dimensions = {1, 2, 2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}},
.operations = {{
.inputs = {0, 1, 2},
.outputs = {3},
.type = TestOperationType::DEPTH_TO_SPACE
}},
.outputIndexes = {3}
},
.minSupportedVersion = TestHalVersion::V1_0,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nhwc = TestModelManager::get().add("depth_to_space_v1_2_nhwc", get_test_model_nhwc());
} // namespace generated_tests::depth_to_space_v1_2
namespace generated_tests::depth_to_space_v1_2 {
const TestModel& get_test_model_nhwc_all_inputs_as_internal() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {4},
.operands = {{ // op1
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({}),
.dimensions = {1, 1, 1, 8},
.isIgnored = false,
.lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // param
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({2}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::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<float>({1.4f, 2.3f, 3.2f, 4.1f, 5.4f, 6.3f, 7.2f, 8.1f}),
.dimensions = {1, 2, 2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // op1_new
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({1.4f, 2.3f, 3.2f, 4.1f, 5.4f, 6.3f, 7.2f, 8.1f}),
.dimensions = {1, 1, 1, 8},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // placeholder
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({0.0f}),
.dimensions = {1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // param3
.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::DEPTH_TO_SPACE
}},
.outputIndexes = {3}
},
.minSupportedVersion = TestHalVersion::V1_0,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nhwc_all_inputs_as_internal = TestModelManager::get().add("depth_to_space_v1_2_nhwc_all_inputs_as_internal", get_test_model_nhwc_all_inputs_as_internal());
} // namespace generated_tests::depth_to_space_v1_2
namespace generated_tests::depth_to_space_v1_2 {
const TestModel& get_test_model_nhwc_relaxed() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = true,
.main = {
.inputIndexes = {0},
.operands = {{ // op1
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({1.4f, 2.3f, 3.2f, 4.1f, 5.4f, 6.3f, 7.2f, 8.1f}),
.dimensions = {1, 1, 1, 8},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // param
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({2}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::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<float>({1.4f, 2.3f, 3.2f, 4.1f, 5.4f, 6.3f, 7.2f, 8.1f}),
.dimensions = {1, 2, 2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}},
.operations = {{
.inputs = {0, 1, 2},
.outputs = {3},
.type = TestOperationType::DEPTH_TO_SPACE
}},
.outputIndexes = {3}
},
.minSupportedVersion = TestHalVersion::UNKNOWN,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nhwc_relaxed = TestModelManager::get().add("depth_to_space_v1_2_nhwc_relaxed", get_test_model_nhwc_relaxed());
} // namespace generated_tests::depth_to_space_v1_2
namespace generated_tests::depth_to_space_v1_2 {
const TestModel& get_test_model_nhwc_relaxed_all_inputs_as_internal() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = true,
.main = {
.inputIndexes = {4},
.operands = {{ // op1
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({}),
.dimensions = {1, 1, 1, 8},
.isIgnored = false,
.lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // param
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({2}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::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<float>({1.4f, 2.3f, 3.2f, 4.1f, 5.4f, 6.3f, 7.2f, 8.1f}),
.dimensions = {1, 2, 2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // op1_new
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({1.4f, 2.3f, 3.2f, 4.1f, 5.4f, 6.3f, 7.2f, 8.1f}),
.dimensions = {1, 1, 1, 8},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // placeholder1
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({0.0f}),
.dimensions = {1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // 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::DEPTH_TO_SPACE
}},
.outputIndexes = {3}
},
.minSupportedVersion = TestHalVersion::UNKNOWN,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nhwc_relaxed_all_inputs_as_internal = TestModelManager::get().add("depth_to_space_v1_2_nhwc_relaxed_all_inputs_as_internal", get_test_model_nhwc_relaxed_all_inputs_as_internal());
} // namespace generated_tests::depth_to_space_v1_2
namespace generated_tests::depth_to_space_v1_2 {
const TestModel& get_test_model_nhwc_float16() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {0},
.operands = {{ // op1
.channelQuant = {},
.data = TestBuffer::createFromVector<_Float16>({1.399999976158142f, 2.299999952316284f, 3.200000047683716f, 4.099999904632568f, 5.400000095367432f, 6.300000190734863f, 7.199999809265137f, 8.100000381469727f}),
.dimensions = {1, 1, 1, 8},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT16,
.zeroPoint = 0
}, { // param
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({2}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::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<_Float16>({1.399999976158142f, 2.299999952316284f, 3.200000047683716f, 4.099999904632568f, 5.400000095367432f, 6.300000190734863f, 7.199999809265137f, 8.100000381469727f}),
.dimensions = {1, 2, 2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT16,
.zeroPoint = 0
}},
.operations = {{
.inputs = {0, 1, 2},
.outputs = {3},
.type = TestOperationType::DEPTH_TO_SPACE
}},
.outputIndexes = {3}
},
.minSupportedVersion = TestHalVersion::V1_2,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nhwc_float16 = TestModelManager::get().add("depth_to_space_v1_2_nhwc_float16", get_test_model_nhwc_float16());
} // namespace generated_tests::depth_to_space_v1_2
namespace generated_tests::depth_to_space_v1_2 {
const TestModel& get_test_model_nhwc_float16_all_inputs_as_internal() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {4},
.operands = {{ // op1
.channelQuant = {},
.data = TestBuffer::createFromVector<_Float16>({}),
.dimensions = {1, 1, 1, 8},
.isIgnored = false,
.lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT16,
.zeroPoint = 0
}, { // param
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({2}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::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<_Float16>({1.399999976158142f, 2.299999952316284f, 3.200000047683716f, 4.099999904632568f, 5.400000095367432f, 6.300000190734863f, 7.199999809265137f, 8.100000381469727f}),
.dimensions = {1, 2, 2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT16,
.zeroPoint = 0
}, { // op1_new
.channelQuant = {},
.data = TestBuffer::createFromVector<_Float16>({1.399999976158142f, 2.299999952316284f, 3.200000047683716f, 4.099999904632568f, 5.400000095367432f, 6.300000190734863f, 7.199999809265137f, 8.100000381469727f}),
.dimensions = {1, 1, 1, 8},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT16,
.zeroPoint = 0
}, { // placeholder2
.channelQuant = {},
.data = TestBuffer::createFromVector<_Float16>({0.0f}),
.dimensions = {1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT16,
.zeroPoint = 0
}, { // 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::DEPTH_TO_SPACE
}},
.outputIndexes = {3}
},
.minSupportedVersion = TestHalVersion::V1_2,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nhwc_float16_all_inputs_as_internal = TestModelManager::get().add("depth_to_space_v1_2_nhwc_float16_all_inputs_as_internal", get_test_model_nhwc_float16_all_inputs_as_internal());
} // namespace generated_tests::depth_to_space_v1_2
namespace generated_tests::depth_to_space_v1_2 {
const TestModel& get_test_model_nhwc_quant8() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {0},
.operands = {{ // op1
.channelQuant = {},
.data = TestBuffer::createFromVector<uint8_t>({14, 23, 32, 41, 54, 63, 72, 81}),
.dimensions = {1, 1, 1, 8},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.1f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM,
.zeroPoint = 0
}, { // param
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({2}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::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<uint8_t>({14, 23, 32, 41, 54, 63, 72, 81}),
.dimensions = {1, 2, 2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.1f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM,
.zeroPoint = 0
}},
.operations = {{
.inputs = {0, 1, 2},
.outputs = {3},
.type = TestOperationType::DEPTH_TO_SPACE
}},
.outputIndexes = {3}
},
.minSupportedVersion = TestHalVersion::V1_0,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nhwc_quant8 = TestModelManager::get().add("depth_to_space_v1_2_nhwc_quant8", get_test_model_nhwc_quant8());
} // namespace generated_tests::depth_to_space_v1_2
namespace generated_tests::depth_to_space_v1_2 {
const TestModel& get_test_model_nhwc_quant8_all_inputs_as_internal() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {4},
.operands = {{ // op1
.channelQuant = {},
.data = TestBuffer::createFromVector<uint8_t>({}),
.dimensions = {1, 1, 1, 8},
.isIgnored = false,
.lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
.numberOfConsumers = 1,
.scale = 0.1f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM,
.zeroPoint = 0
}, { // param
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({2}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::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<uint8_t>({14, 23, 32, 41, 54, 63, 72, 81}),
.dimensions = {1, 2, 2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.1f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM,
.zeroPoint = 0
}, { // op1_new
.channelQuant = {},
.data = TestBuffer::createFromVector<uint8_t>({14, 23, 32, 41, 54, 63, 72, 81}),
.dimensions = {1, 1, 1, 8},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.1f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM,
.zeroPoint = 0
}, { // placeholder3
.channelQuant = {},
.data = TestBuffer::createFromVector<uint8_t>({0}),
.dimensions = {1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.1f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM,
.zeroPoint = 0
}, { // 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::DEPTH_TO_SPACE
}},
.outputIndexes = {3}
},
.minSupportedVersion = TestHalVersion::V1_0,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nhwc_quant8_all_inputs_as_internal = TestModelManager::get().add("depth_to_space_v1_2_nhwc_quant8_all_inputs_as_internal", get_test_model_nhwc_quant8_all_inputs_as_internal());
} // namespace generated_tests::depth_to_space_v1_2
namespace generated_tests::depth_to_space_v1_2 {
const TestModel& get_test_model_nchw() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {0},
.operands = {{ // op1
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({1.4f, 2.3f, 3.2f, 4.1f, 5.4f, 6.3f, 7.2f, 8.1f}),
.dimensions = {1, 8, 1, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // param
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({2}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::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<float>({1.4f, 3.2f, 5.4f, 7.2f, 2.3f, 4.1f, 6.3f, 8.1f}),
.dimensions = {1, 2, 2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}},
.operations = {{
.inputs = {0, 1, 2},
.outputs = {3},
.type = TestOperationType::DEPTH_TO_SPACE
}},
.outputIndexes = {3}
},
.minSupportedVersion = TestHalVersion::V1_2,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nchw = TestModelManager::get().add("depth_to_space_v1_2_nchw", get_test_model_nchw());
} // namespace generated_tests::depth_to_space_v1_2
namespace generated_tests::depth_to_space_v1_2 {
const TestModel& get_test_model_nchw_all_inputs_as_internal() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {4},
.operands = {{ // op1
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({}),
.dimensions = {1, 8, 1, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // param
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({2}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::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<float>({1.4f, 3.2f, 5.4f, 7.2f, 2.3f, 4.1f, 6.3f, 8.1f}),
.dimensions = {1, 2, 2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // op1_new
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({1.4f, 2.3f, 3.2f, 4.1f, 5.4f, 6.3f, 7.2f, 8.1f}),
.dimensions = {1, 8, 1, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // placeholder4
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({0.0f}),
.dimensions = {1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // 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::DEPTH_TO_SPACE
}},
.outputIndexes = {3}
},
.minSupportedVersion = TestHalVersion::V1_2,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nchw_all_inputs_as_internal = TestModelManager::get().add("depth_to_space_v1_2_nchw_all_inputs_as_internal", get_test_model_nchw_all_inputs_as_internal());
} // namespace generated_tests::depth_to_space_v1_2
namespace generated_tests::depth_to_space_v1_2 {
const TestModel& get_test_model_nchw_relaxed() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = true,
.main = {
.inputIndexes = {0},
.operands = {{ // op1
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({1.4f, 2.3f, 3.2f, 4.1f, 5.4f, 6.3f, 7.2f, 8.1f}),
.dimensions = {1, 8, 1, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // param
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({2}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::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<float>({1.4f, 3.2f, 5.4f, 7.2f, 2.3f, 4.1f, 6.3f, 8.1f}),
.dimensions = {1, 2, 2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}},
.operations = {{
.inputs = {0, 1, 2},
.outputs = {3},
.type = TestOperationType::DEPTH_TO_SPACE
}},
.outputIndexes = {3}
},
.minSupportedVersion = TestHalVersion::UNKNOWN,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nchw_relaxed = TestModelManager::get().add("depth_to_space_v1_2_nchw_relaxed", get_test_model_nchw_relaxed());
} // namespace generated_tests::depth_to_space_v1_2
namespace generated_tests::depth_to_space_v1_2 {
const TestModel& get_test_model_nchw_relaxed_all_inputs_as_internal() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = true,
.main = {
.inputIndexes = {4},
.operands = {{ // op1
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({}),
.dimensions = {1, 8, 1, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // param
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({2}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::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<float>({1.4f, 3.2f, 5.4f, 7.2f, 2.3f, 4.1f, 6.3f, 8.1f}),
.dimensions = {1, 2, 2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // op1_new
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({1.4f, 2.3f, 3.2f, 4.1f, 5.4f, 6.3f, 7.2f, 8.1f}),
.dimensions = {1, 8, 1, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // placeholder5
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({0.0f}),
.dimensions = {1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // 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::DEPTH_TO_SPACE
}},
.outputIndexes = {3}
},
.minSupportedVersion = TestHalVersion::UNKNOWN,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nchw_relaxed_all_inputs_as_internal = TestModelManager::get().add("depth_to_space_v1_2_nchw_relaxed_all_inputs_as_internal", get_test_model_nchw_relaxed_all_inputs_as_internal());
} // namespace generated_tests::depth_to_space_v1_2
namespace generated_tests::depth_to_space_v1_2 {
const TestModel& get_test_model_nchw_float16() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {0},
.operands = {{ // op1
.channelQuant = {},
.data = TestBuffer::createFromVector<_Float16>({1.399999976158142f, 2.299999952316284f, 3.200000047683716f, 4.099999904632568f, 5.400000095367432f, 6.300000190734863f, 7.199999809265137f, 8.100000381469727f}),
.dimensions = {1, 8, 1, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT16,
.zeroPoint = 0
}, { // param
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({2}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::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<_Float16>({1.399999976158142f, 3.200000047683716f, 5.400000095367432f, 7.199999809265137f, 2.299999952316284f, 4.099999904632568f, 6.300000190734863f, 8.100000381469727f}),
.dimensions = {1, 2, 2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT16,
.zeroPoint = 0
}},
.operations = {{
.inputs = {0, 1, 2},
.outputs = {3},
.type = TestOperationType::DEPTH_TO_SPACE
}},
.outputIndexes = {3}
},
.minSupportedVersion = TestHalVersion::V1_2,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nchw_float16 = TestModelManager::get().add("depth_to_space_v1_2_nchw_float16", get_test_model_nchw_float16());
} // namespace generated_tests::depth_to_space_v1_2
namespace generated_tests::depth_to_space_v1_2 {
const TestModel& get_test_model_nchw_float16_all_inputs_as_internal() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {4},
.operands = {{ // op1
.channelQuant = {},
.data = TestBuffer::createFromVector<_Float16>({}),
.dimensions = {1, 8, 1, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT16,
.zeroPoint = 0
}, { // param
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({2}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::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<_Float16>({1.399999976158142f, 3.200000047683716f, 5.400000095367432f, 7.199999809265137f, 2.299999952316284f, 4.099999904632568f, 6.300000190734863f, 8.100000381469727f}),
.dimensions = {1, 2, 2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT16,
.zeroPoint = 0
}, { // op1_new
.channelQuant = {},
.data = TestBuffer::createFromVector<_Float16>({1.399999976158142f, 2.299999952316284f, 3.200000047683716f, 4.099999904632568f, 5.400000095367432f, 6.300000190734863f, 7.199999809265137f, 8.100000381469727f}),
.dimensions = {1, 8, 1, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT16,
.zeroPoint = 0
}, { // placeholder6
.channelQuant = {},
.data = TestBuffer::createFromVector<_Float16>({0.0f}),
.dimensions = {1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT16,
.zeroPoint = 0
}, { // 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::DEPTH_TO_SPACE
}},
.outputIndexes = {3}
},
.minSupportedVersion = TestHalVersion::V1_2,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nchw_float16_all_inputs_as_internal = TestModelManager::get().add("depth_to_space_v1_2_nchw_float16_all_inputs_as_internal", get_test_model_nchw_float16_all_inputs_as_internal());
} // namespace generated_tests::depth_to_space_v1_2
namespace generated_tests::depth_to_space_v1_2 {
const TestModel& get_test_model_nchw_quant8() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {0},
.operands = {{ // op1
.channelQuant = {},
.data = TestBuffer::createFromVector<uint8_t>({14, 23, 32, 41, 54, 63, 72, 81}),
.dimensions = {1, 8, 1, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.1f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM,
.zeroPoint = 0
}, { // param
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({2}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::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<uint8_t>({14, 32, 54, 72, 23, 41, 63, 81}),
.dimensions = {1, 2, 2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.1f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM,
.zeroPoint = 0
}},
.operations = {{
.inputs = {0, 1, 2},
.outputs = {3},
.type = TestOperationType::DEPTH_TO_SPACE
}},
.outputIndexes = {3}
},
.minSupportedVersion = TestHalVersion::V1_2,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nchw_quant8 = TestModelManager::get().add("depth_to_space_v1_2_nchw_quant8", get_test_model_nchw_quant8());
} // namespace generated_tests::depth_to_space_v1_2
namespace generated_tests::depth_to_space_v1_2 {
const TestModel& get_test_model_nchw_quant8_all_inputs_as_internal() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {4},
.operands = {{ // op1
.channelQuant = {},
.data = TestBuffer::createFromVector<uint8_t>({}),
.dimensions = {1, 8, 1, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
.numberOfConsumers = 1,
.scale = 0.1f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM,
.zeroPoint = 0
}, { // param
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({2}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::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<uint8_t>({14, 32, 54, 72, 23, 41, 63, 81}),
.dimensions = {1, 2, 2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.1f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM,
.zeroPoint = 0
}, { // op1_new
.channelQuant = {},
.data = TestBuffer::createFromVector<uint8_t>({14, 23, 32, 41, 54, 63, 72, 81}),
.dimensions = {1, 8, 1, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.1f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM,
.zeroPoint = 0
}, { // placeholder7
.channelQuant = {},
.data = TestBuffer::createFromVector<uint8_t>({0}),
.dimensions = {1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.1f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM,
.zeroPoint = 0
}, { // 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::DEPTH_TO_SPACE
}},
.outputIndexes = {3}
},
.minSupportedVersion = TestHalVersion::V1_2,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nchw_quant8_all_inputs_as_internal = TestModelManager::get().add("depth_to_space_v1_2_nchw_quant8_all_inputs_as_internal", get_test_model_nchw_quant8_all_inputs_as_internal());
} // namespace generated_tests::depth_to_space_v1_2
namespace generated_tests::depth_to_space_v1_2 {
const TestModel& get_test_model_nhwc_2() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {0},
.operands = {{ // op11
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({1.0f, 2.0f, 5.0f, 6.0f, 3.0f, 4.0f, 7.0f, 8.0f, 9.0f, 10.0f, 13.0f, 14.0f, 11.0f, 12.0f, 15.0f, 16.0f}),
.dimensions = {1, 2, 2, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // param1
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({2}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::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<float>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f}),
.dimensions = {1, 4, 4, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}},
.operations = {{
.inputs = {0, 1, 2},
.outputs = {3},
.type = TestOperationType::DEPTH_TO_SPACE
}},
.outputIndexes = {3}
},
.minSupportedVersion = TestHalVersion::V1_0,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nhwc_2 = TestModelManager::get().add("depth_to_space_v1_2_nhwc_2", get_test_model_nhwc_2());
} // namespace generated_tests::depth_to_space_v1_2
namespace generated_tests::depth_to_space_v1_2 {
const TestModel& get_test_model_nhwc_all_inputs_as_internal_2() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {4},
.operands = {{ // op11
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({}),
.dimensions = {1, 2, 2, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // param1
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({2}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::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<float>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f}),
.dimensions = {1, 4, 4, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // op11_new
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({1.0f, 2.0f, 5.0f, 6.0f, 3.0f, 4.0f, 7.0f, 8.0f, 9.0f, 10.0f, 13.0f, 14.0f, 11.0f, 12.0f, 15.0f, 16.0f}),
.dimensions = {1, 2, 2, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // placeholder8
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({0.0f}),
.dimensions = {1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // 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::DEPTH_TO_SPACE
}},
.outputIndexes = {3}
},
.minSupportedVersion = TestHalVersion::V1_0,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nhwc_all_inputs_as_internal_2 = TestModelManager::get().add("depth_to_space_v1_2_nhwc_all_inputs_as_internal_2", get_test_model_nhwc_all_inputs_as_internal_2());
} // namespace generated_tests::depth_to_space_v1_2
namespace generated_tests::depth_to_space_v1_2 {
const TestModel& get_test_model_nhwc_relaxed_2() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = true,
.main = {
.inputIndexes = {0},
.operands = {{ // op11
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({1.0f, 2.0f, 5.0f, 6.0f, 3.0f, 4.0f, 7.0f, 8.0f, 9.0f, 10.0f, 13.0f, 14.0f, 11.0f, 12.0f, 15.0f, 16.0f}),
.dimensions = {1, 2, 2, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // param1
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({2}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::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<float>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f}),
.dimensions = {1, 4, 4, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}},
.operations = {{
.inputs = {0, 1, 2},
.outputs = {3},
.type = TestOperationType::DEPTH_TO_SPACE
}},
.outputIndexes = {3}
},
.minSupportedVersion = TestHalVersion::UNKNOWN,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nhwc_relaxed_2 = TestModelManager::get().add("depth_to_space_v1_2_nhwc_relaxed_2", get_test_model_nhwc_relaxed_2());
} // namespace generated_tests::depth_to_space_v1_2
namespace generated_tests::depth_to_space_v1_2 {
const TestModel& get_test_model_nhwc_relaxed_all_inputs_as_internal_2() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = true,
.main = {
.inputIndexes = {4},
.operands = {{ // op11
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({}),
.dimensions = {1, 2, 2, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // param1
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({2}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::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<float>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f}),
.dimensions = {1, 4, 4, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // op11_new
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({1.0f, 2.0f, 5.0f, 6.0f, 3.0f, 4.0f, 7.0f, 8.0f, 9.0f, 10.0f, 13.0f, 14.0f, 11.0f, 12.0f, 15.0f, 16.0f}),
.dimensions = {1, 2, 2, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // placeholder9
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({0.0f}),
.dimensions = {1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // 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 = {4, 5, 6},
.outputs = {0},
.type = TestOperationType::ADD
}, {
.inputs = {0, 1, 2},
.outputs = {3},
.type = TestOperationType::DEPTH_TO_SPACE
}},
.outputIndexes = {3}
},
.minSupportedVersion = TestHalVersion::UNKNOWN,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nhwc_relaxed_all_inputs_as_internal_2 = TestModelManager::get().add("depth_to_space_v1_2_nhwc_relaxed_all_inputs_as_internal_2", get_test_model_nhwc_relaxed_all_inputs_as_internal_2());
} // namespace generated_tests::depth_to_space_v1_2
namespace generated_tests::depth_to_space_v1_2 {
const TestModel& get_test_model_nhwc_float16_2() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {0},
.operands = {{ // op11
.channelQuant = {},
.data = TestBuffer::createFromVector<_Float16>({1.0f, 2.0f, 5.0f, 6.0f, 3.0f, 4.0f, 7.0f, 8.0f, 9.0f, 10.0f, 13.0f, 14.0f, 11.0f, 12.0f, 15.0f, 16.0f}),
.dimensions = {1, 2, 2, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT16,
.zeroPoint = 0
}, { // param1
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({2}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::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<_Float16>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f}),
.dimensions = {1, 4, 4, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT16,
.zeroPoint = 0
}},
.operations = {{
.inputs = {0, 1, 2},
.outputs = {3},
.type = TestOperationType::DEPTH_TO_SPACE
}},
.outputIndexes = {3}
},
.minSupportedVersion = TestHalVersion::V1_2,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nhwc_float16_2 = TestModelManager::get().add("depth_to_space_v1_2_nhwc_float16_2", get_test_model_nhwc_float16_2());
} // namespace generated_tests::depth_to_space_v1_2
namespace generated_tests::depth_to_space_v1_2 {
const TestModel& get_test_model_nhwc_float16_all_inputs_as_internal_2() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {4},
.operands = {{ // op11
.channelQuant = {},
.data = TestBuffer::createFromVector<_Float16>({}),
.dimensions = {1, 2, 2, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT16,
.zeroPoint = 0
}, { // param1
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({2}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::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<_Float16>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f}),
.dimensions = {1, 4, 4, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT16,
.zeroPoint = 0
}, { // op11_new
.channelQuant = {},
.data = TestBuffer::createFromVector<_Float16>({1.0f, 2.0f, 5.0f, 6.0f, 3.0f, 4.0f, 7.0f, 8.0f, 9.0f, 10.0f, 13.0f, 14.0f, 11.0f, 12.0f, 15.0f, 16.0f}),
.dimensions = {1, 2, 2, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT16,
.zeroPoint = 0
}, { // placeholder10
.channelQuant = {},
.data = TestBuffer::createFromVector<_Float16>({0.0f}),
.dimensions = {1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT16,
.zeroPoint = 0
}, { // 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 = {4, 5, 6},
.outputs = {0},
.type = TestOperationType::ADD
}, {
.inputs = {0, 1, 2},
.outputs = {3},
.type = TestOperationType::DEPTH_TO_SPACE
}},
.outputIndexes = {3}
},
.minSupportedVersion = TestHalVersion::V1_2,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nhwc_float16_all_inputs_as_internal_2 = TestModelManager::get().add("depth_to_space_v1_2_nhwc_float16_all_inputs_as_internal_2", get_test_model_nhwc_float16_all_inputs_as_internal_2());
} // namespace generated_tests::depth_to_space_v1_2
namespace generated_tests::depth_to_space_v1_2 {
const TestModel& get_test_model_nhwc_quant8_2() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {0},
.operands = {{ // op11
.channelQuant = {},
.data = TestBuffer::createFromVector<uint8_t>({130, 132, 138, 140, 134, 136, 142, 144, 146, 148, 154, 156, 150, 152, 158, 160}),
.dimensions = {1, 2, 2, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.5f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM,
.zeroPoint = 128
}, { // param1
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({2}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::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<uint8_t>({130, 132, 134, 136, 138, 140, 142, 144, 146, 148, 150, 152, 154, 156, 158, 160}),
.dimensions = {1, 4, 4, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.5f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM,
.zeroPoint = 128
}},
.operations = {{
.inputs = {0, 1, 2},
.outputs = {3},
.type = TestOperationType::DEPTH_TO_SPACE
}},
.outputIndexes = {3}
},
.minSupportedVersion = TestHalVersion::V1_0,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nhwc_quant8_2 = TestModelManager::get().add("depth_to_space_v1_2_nhwc_quant8_2", get_test_model_nhwc_quant8_2());
} // namespace generated_tests::depth_to_space_v1_2
namespace generated_tests::depth_to_space_v1_2 {
const TestModel& get_test_model_nhwc_quant8_all_inputs_as_internal_2() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {4},
.operands = {{ // op11
.channelQuant = {},
.data = TestBuffer::createFromVector<uint8_t>({}),
.dimensions = {1, 2, 2, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
.numberOfConsumers = 1,
.scale = 0.5f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM,
.zeroPoint = 128
}, { // param1
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({2}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::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<uint8_t>({130, 132, 134, 136, 138, 140, 142, 144, 146, 148, 150, 152, 154, 156, 158, 160}),
.dimensions = {1, 4, 4, 1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.5f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM,
.zeroPoint = 128
}, { // op11_new
.channelQuant = {},
.data = TestBuffer::createFromVector<uint8_t>({130, 132, 138, 140, 134, 136, 142, 144, 146, 148, 154, 156, 150, 152, 158, 160}),
.dimensions = {1, 2, 2, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.5f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM,
.zeroPoint = 128
}, { // placeholder11
.channelQuant = {},
.data = TestBuffer::createFromVector<uint8_t>({128}),
.dimensions = {1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.5f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM,
.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 = {4, 5, 6},
.outputs = {0},
.type = TestOperationType::ADD
}, {
.inputs = {0, 1, 2},
.outputs = {3},
.type = TestOperationType::DEPTH_TO_SPACE
}},
.outputIndexes = {3}
},
.minSupportedVersion = TestHalVersion::V1_0,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nhwc_quant8_all_inputs_as_internal_2 = TestModelManager::get().add("depth_to_space_v1_2_nhwc_quant8_all_inputs_as_internal_2", get_test_model_nhwc_quant8_all_inputs_as_internal_2());
} // namespace generated_tests::depth_to_space_v1_2
namespace generated_tests::depth_to_space_v1_2 {
const TestModel& get_test_model_nchw_2() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {0},
.operands = {{ // op11
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({1.0f, 3.0f, 9.0f, 11.0f, 2.0f, 4.0f, 10.0f, 12.0f, 5.0f, 7.0f, 13.0f, 15.0f, 6.0f, 8.0f, 14.0f, 16.0f}),
.dimensions = {1, 4, 2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // param1
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({2}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::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<float>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f}),
.dimensions = {1, 1, 4, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}},
.operations = {{
.inputs = {0, 1, 2},
.outputs = {3},
.type = TestOperationType::DEPTH_TO_SPACE
}},
.outputIndexes = {3}
},
.minSupportedVersion = TestHalVersion::V1_2,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nchw_2 = TestModelManager::get().add("depth_to_space_v1_2_nchw_2", get_test_model_nchw_2());
} // namespace generated_tests::depth_to_space_v1_2
namespace generated_tests::depth_to_space_v1_2 {
const TestModel& get_test_model_nchw_all_inputs_as_internal_2() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {4},
.operands = {{ // op11
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({}),
.dimensions = {1, 4, 2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // param1
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({2}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::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<float>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f}),
.dimensions = {1, 1, 4, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // op11_new
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({1.0f, 3.0f, 9.0f, 11.0f, 2.0f, 4.0f, 10.0f, 12.0f, 5.0f, 7.0f, 13.0f, 15.0f, 6.0f, 8.0f, 14.0f, 16.0f}),
.dimensions = {1, 4, 2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // placeholder12
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({0.0f}),
.dimensions = {1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // 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 = {4, 5, 6},
.outputs = {0},
.type = TestOperationType::ADD
}, {
.inputs = {0, 1, 2},
.outputs = {3},
.type = TestOperationType::DEPTH_TO_SPACE
}},
.outputIndexes = {3}
},
.minSupportedVersion = TestHalVersion::V1_2,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nchw_all_inputs_as_internal_2 = TestModelManager::get().add("depth_to_space_v1_2_nchw_all_inputs_as_internal_2", get_test_model_nchw_all_inputs_as_internal_2());
} // namespace generated_tests::depth_to_space_v1_2
namespace generated_tests::depth_to_space_v1_2 {
const TestModel& get_test_model_nchw_relaxed_2() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = true,
.main = {
.inputIndexes = {0},
.operands = {{ // op11
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({1.0f, 3.0f, 9.0f, 11.0f, 2.0f, 4.0f, 10.0f, 12.0f, 5.0f, 7.0f, 13.0f, 15.0f, 6.0f, 8.0f, 14.0f, 16.0f}),
.dimensions = {1, 4, 2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // param1
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({2}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::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<float>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f}),
.dimensions = {1, 1, 4, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}},
.operations = {{
.inputs = {0, 1, 2},
.outputs = {3},
.type = TestOperationType::DEPTH_TO_SPACE
}},
.outputIndexes = {3}
},
.minSupportedVersion = TestHalVersion::UNKNOWN,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nchw_relaxed_2 = TestModelManager::get().add("depth_to_space_v1_2_nchw_relaxed_2", get_test_model_nchw_relaxed_2());
} // namespace generated_tests::depth_to_space_v1_2
namespace generated_tests::depth_to_space_v1_2 {
const TestModel& get_test_model_nchw_relaxed_all_inputs_as_internal_2() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = true,
.main = {
.inputIndexes = {4},
.operands = {{ // op11
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({}),
.dimensions = {1, 4, 2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // param1
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({2}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::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<float>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f}),
.dimensions = {1, 1, 4, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // op11_new
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({1.0f, 3.0f, 9.0f, 11.0f, 2.0f, 4.0f, 10.0f, 12.0f, 5.0f, 7.0f, 13.0f, 15.0f, 6.0f, 8.0f, 14.0f, 16.0f}),
.dimensions = {1, 4, 2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // placeholder13
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({0.0f}),
.dimensions = {1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // 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 = {4, 5, 6},
.outputs = {0},
.type = TestOperationType::ADD
}, {
.inputs = {0, 1, 2},
.outputs = {3},
.type = TestOperationType::DEPTH_TO_SPACE
}},
.outputIndexes = {3}
},
.minSupportedVersion = TestHalVersion::UNKNOWN,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nchw_relaxed_all_inputs_as_internal_2 = TestModelManager::get().add("depth_to_space_v1_2_nchw_relaxed_all_inputs_as_internal_2", get_test_model_nchw_relaxed_all_inputs_as_internal_2());
} // namespace generated_tests::depth_to_space_v1_2
namespace generated_tests::depth_to_space_v1_2 {
const TestModel& get_test_model_nchw_float16_2() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {0},
.operands = {{ // op11
.channelQuant = {},
.data = TestBuffer::createFromVector<_Float16>({1.0f, 3.0f, 9.0f, 11.0f, 2.0f, 4.0f, 10.0f, 12.0f, 5.0f, 7.0f, 13.0f, 15.0f, 6.0f, 8.0f, 14.0f, 16.0f}),
.dimensions = {1, 4, 2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT16,
.zeroPoint = 0
}, { // param1
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({2}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::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<_Float16>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f}),
.dimensions = {1, 1, 4, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT16,
.zeroPoint = 0
}},
.operations = {{
.inputs = {0, 1, 2},
.outputs = {3},
.type = TestOperationType::DEPTH_TO_SPACE
}},
.outputIndexes = {3}
},
.minSupportedVersion = TestHalVersion::V1_2,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nchw_float16_2 = TestModelManager::get().add("depth_to_space_v1_2_nchw_float16_2", get_test_model_nchw_float16_2());
} // namespace generated_tests::depth_to_space_v1_2
namespace generated_tests::depth_to_space_v1_2 {
const TestModel& get_test_model_nchw_float16_all_inputs_as_internal_2() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {4},
.operands = {{ // op11
.channelQuant = {},
.data = TestBuffer::createFromVector<_Float16>({}),
.dimensions = {1, 4, 2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT16,
.zeroPoint = 0
}, { // param1
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({2}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::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<_Float16>({1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f}),
.dimensions = {1, 1, 4, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT16,
.zeroPoint = 0
}, { // op11_new
.channelQuant = {},
.data = TestBuffer::createFromVector<_Float16>({1.0f, 3.0f, 9.0f, 11.0f, 2.0f, 4.0f, 10.0f, 12.0f, 5.0f, 7.0f, 13.0f, 15.0f, 6.0f, 8.0f, 14.0f, 16.0f}),
.dimensions = {1, 4, 2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT16,
.zeroPoint = 0
}, { // placeholder14
.channelQuant = {},
.data = TestBuffer::createFromVector<_Float16>({0.0f}),
.dimensions = {1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT16,
.zeroPoint = 0
}, { // 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 = {4, 5, 6},
.outputs = {0},
.type = TestOperationType::ADD
}, {
.inputs = {0, 1, 2},
.outputs = {3},
.type = TestOperationType::DEPTH_TO_SPACE
}},
.outputIndexes = {3}
},
.minSupportedVersion = TestHalVersion::V1_2,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nchw_float16_all_inputs_as_internal_2 = TestModelManager::get().add("depth_to_space_v1_2_nchw_float16_all_inputs_as_internal_2", get_test_model_nchw_float16_all_inputs_as_internal_2());
} // namespace generated_tests::depth_to_space_v1_2
namespace generated_tests::depth_to_space_v1_2 {
const TestModel& get_test_model_nchw_quant8_2() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {0},
.operands = {{ // op11
.channelQuant = {},
.data = TestBuffer::createFromVector<uint8_t>({130, 134, 146, 150, 132, 136, 148, 152, 138, 142, 154, 158, 140, 144, 156, 160}),
.dimensions = {1, 4, 2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.5f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM,
.zeroPoint = 128
}, { // param1
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({2}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::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<uint8_t>({130, 132, 134, 136, 138, 140, 142, 144, 146, 148, 150, 152, 154, 156, 158, 160}),
.dimensions = {1, 1, 4, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.5f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM,
.zeroPoint = 128
}},
.operations = {{
.inputs = {0, 1, 2},
.outputs = {3},
.type = TestOperationType::DEPTH_TO_SPACE
}},
.outputIndexes = {3}
},
.minSupportedVersion = TestHalVersion::V1_2,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nchw_quant8_2 = TestModelManager::get().add("depth_to_space_v1_2_nchw_quant8_2", get_test_model_nchw_quant8_2());
} // namespace generated_tests::depth_to_space_v1_2
namespace generated_tests::depth_to_space_v1_2 {
const TestModel& get_test_model_nchw_quant8_all_inputs_as_internal_2() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {4},
.operands = {{ // op11
.channelQuant = {},
.data = TestBuffer::createFromVector<uint8_t>({}),
.dimensions = {1, 4, 2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
.numberOfConsumers = 1,
.scale = 0.5f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM,
.zeroPoint = 128
}, { // param1
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({2}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::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<uint8_t>({130, 132, 134, 136, 138, 140, 142, 144, 146, 148, 150, 152, 154, 156, 158, 160}),
.dimensions = {1, 1, 4, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.5f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM,
.zeroPoint = 128
}, { // op11_new
.channelQuant = {},
.data = TestBuffer::createFromVector<uint8_t>({130, 134, 146, 150, 132, 136, 148, 152, 138, 142, 154, 158, 140, 144, 156, 160}),
.dimensions = {1, 4, 2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.5f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM,
.zeroPoint = 128
}, { // placeholder15
.channelQuant = {},
.data = TestBuffer::createFromVector<uint8_t>({128}),
.dimensions = {1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.5f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM,
.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 = {4, 5, 6},
.outputs = {0},
.type = TestOperationType::ADD
}, {
.inputs = {0, 1, 2},
.outputs = {3},
.type = TestOperationType::DEPTH_TO_SPACE
}},
.outputIndexes = {3}
},
.minSupportedVersion = TestHalVersion::V1_2,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nchw_quant8_all_inputs_as_internal_2 = TestModelManager::get().add("depth_to_space_v1_2_nchw_quant8_all_inputs_as_internal_2", get_test_model_nchw_quant8_all_inputs_as_internal_2());
} // namespace generated_tests::depth_to_space_v1_2
namespace generated_tests::depth_to_space_v1_2 {
const TestModel& get_test_model_nhwc_3() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {0},
.operands = {{ // op12
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({10.0f, 20.0f, 11.0f, 21.0f, 14.0f, 24.0f, 15.0f, 25.0f, 12.0f, 22.0f, 13.0f, 23.0f, 16.0f, 26.0f, 17.0f, 27.0f, 18.0f, 28.0f, 19.0f, 29.0f, 112.0f, 212.0f, 113.0f, 213.0f, 110.0f, 210.0f, 111.0f, 211.0f, 114.0f, 214.0f, 115.0f, 215.0f}),
.dimensions = {1, 2, 2, 8},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // param2
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({2}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::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<float>({10.0f, 20.0f, 11.0f, 21.0f, 12.0f, 22.0f, 13.0f, 23.0f, 14.0f, 24.0f, 15.0f, 25.0f, 16.0f, 26.0f, 17.0f, 27.0f, 18.0f, 28.0f, 19.0f, 29.0f, 110.0f, 210.0f, 111.0f, 211.0f, 112.0f, 212.0f, 113.0f, 213.0f, 114.0f, 214.0f, 115.0f, 215.0f}),
.dimensions = {1, 4, 4, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}},
.operations = {{
.inputs = {0, 1, 2},
.outputs = {3},
.type = TestOperationType::DEPTH_TO_SPACE
}},
.outputIndexes = {3}
},
.minSupportedVersion = TestHalVersion::V1_0,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nhwc_3 = TestModelManager::get().add("depth_to_space_v1_2_nhwc_3", get_test_model_nhwc_3());
} // namespace generated_tests::depth_to_space_v1_2
namespace generated_tests::depth_to_space_v1_2 {
const TestModel& get_test_model_nhwc_all_inputs_as_internal_3() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {4},
.operands = {{ // op12
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({}),
.dimensions = {1, 2, 2, 8},
.isIgnored = false,
.lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // param2
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({2}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::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<float>({10.0f, 20.0f, 11.0f, 21.0f, 12.0f, 22.0f, 13.0f, 23.0f, 14.0f, 24.0f, 15.0f, 25.0f, 16.0f, 26.0f, 17.0f, 27.0f, 18.0f, 28.0f, 19.0f, 29.0f, 110.0f, 210.0f, 111.0f, 211.0f, 112.0f, 212.0f, 113.0f, 213.0f, 114.0f, 214.0f, 115.0f, 215.0f}),
.dimensions = {1, 4, 4, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // op12_new
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({10.0f, 20.0f, 11.0f, 21.0f, 14.0f, 24.0f, 15.0f, 25.0f, 12.0f, 22.0f, 13.0f, 23.0f, 16.0f, 26.0f, 17.0f, 27.0f, 18.0f, 28.0f, 19.0f, 29.0f, 112.0f, 212.0f, 113.0f, 213.0f, 110.0f, 210.0f, 111.0f, 211.0f, 114.0f, 214.0f, 115.0f, 215.0f}),
.dimensions = {1, 2, 2, 8},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // placeholder16
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({0.0f}),
.dimensions = {1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // 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 = {4, 5, 6},
.outputs = {0},
.type = TestOperationType::ADD
}, {
.inputs = {0, 1, 2},
.outputs = {3},
.type = TestOperationType::DEPTH_TO_SPACE
}},
.outputIndexes = {3}
},
.minSupportedVersion = TestHalVersion::V1_0,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nhwc_all_inputs_as_internal_3 = TestModelManager::get().add("depth_to_space_v1_2_nhwc_all_inputs_as_internal_3", get_test_model_nhwc_all_inputs_as_internal_3());
} // namespace generated_tests::depth_to_space_v1_2
namespace generated_tests::depth_to_space_v1_2 {
const TestModel& get_test_model_nhwc_relaxed_3() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = true,
.main = {
.inputIndexes = {0},
.operands = {{ // op12
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({10.0f, 20.0f, 11.0f, 21.0f, 14.0f, 24.0f, 15.0f, 25.0f, 12.0f, 22.0f, 13.0f, 23.0f, 16.0f, 26.0f, 17.0f, 27.0f, 18.0f, 28.0f, 19.0f, 29.0f, 112.0f, 212.0f, 113.0f, 213.0f, 110.0f, 210.0f, 111.0f, 211.0f, 114.0f, 214.0f, 115.0f, 215.0f}),
.dimensions = {1, 2, 2, 8},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // param2
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({2}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::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<float>({10.0f, 20.0f, 11.0f, 21.0f, 12.0f, 22.0f, 13.0f, 23.0f, 14.0f, 24.0f, 15.0f, 25.0f, 16.0f, 26.0f, 17.0f, 27.0f, 18.0f, 28.0f, 19.0f, 29.0f, 110.0f, 210.0f, 111.0f, 211.0f, 112.0f, 212.0f, 113.0f, 213.0f, 114.0f, 214.0f, 115.0f, 215.0f}),
.dimensions = {1, 4, 4, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}},
.operations = {{
.inputs = {0, 1, 2},
.outputs = {3},
.type = TestOperationType::DEPTH_TO_SPACE
}},
.outputIndexes = {3}
},
.minSupportedVersion = TestHalVersion::UNKNOWN,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nhwc_relaxed_3 = TestModelManager::get().add("depth_to_space_v1_2_nhwc_relaxed_3", get_test_model_nhwc_relaxed_3());
} // namespace generated_tests::depth_to_space_v1_2
namespace generated_tests::depth_to_space_v1_2 {
const TestModel& get_test_model_nhwc_relaxed_all_inputs_as_internal_3() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = true,
.main = {
.inputIndexes = {4},
.operands = {{ // op12
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({}),
.dimensions = {1, 2, 2, 8},
.isIgnored = false,
.lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // param2
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({2}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::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<float>({10.0f, 20.0f, 11.0f, 21.0f, 12.0f, 22.0f, 13.0f, 23.0f, 14.0f, 24.0f, 15.0f, 25.0f, 16.0f, 26.0f, 17.0f, 27.0f, 18.0f, 28.0f, 19.0f, 29.0f, 110.0f, 210.0f, 111.0f, 211.0f, 112.0f, 212.0f, 113.0f, 213.0f, 114.0f, 214.0f, 115.0f, 215.0f}),
.dimensions = {1, 4, 4, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // op12_new
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({10.0f, 20.0f, 11.0f, 21.0f, 14.0f, 24.0f, 15.0f, 25.0f, 12.0f, 22.0f, 13.0f, 23.0f, 16.0f, 26.0f, 17.0f, 27.0f, 18.0f, 28.0f, 19.0f, 29.0f, 112.0f, 212.0f, 113.0f, 213.0f, 110.0f, 210.0f, 111.0f, 211.0f, 114.0f, 214.0f, 115.0f, 215.0f}),
.dimensions = {1, 2, 2, 8},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // placeholder17
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({0.0f}),
.dimensions = {1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.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 = {4, 5, 6},
.outputs = {0},
.type = TestOperationType::ADD
}, {
.inputs = {0, 1, 2},
.outputs = {3},
.type = TestOperationType::DEPTH_TO_SPACE
}},
.outputIndexes = {3}
},
.minSupportedVersion = TestHalVersion::UNKNOWN,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nhwc_relaxed_all_inputs_as_internal_3 = TestModelManager::get().add("depth_to_space_v1_2_nhwc_relaxed_all_inputs_as_internal_3", get_test_model_nhwc_relaxed_all_inputs_as_internal_3());
} // namespace generated_tests::depth_to_space_v1_2
namespace generated_tests::depth_to_space_v1_2 {
const TestModel& get_test_model_nhwc_float16_3() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {0},
.operands = {{ // op12
.channelQuant = {},
.data = TestBuffer::createFromVector<_Float16>({10.0f, 20.0f, 11.0f, 21.0f, 14.0f, 24.0f, 15.0f, 25.0f, 12.0f, 22.0f, 13.0f, 23.0f, 16.0f, 26.0f, 17.0f, 27.0f, 18.0f, 28.0f, 19.0f, 29.0f, 112.0f, 212.0f, 113.0f, 213.0f, 110.0f, 210.0f, 111.0f, 211.0f, 114.0f, 214.0f, 115.0f, 215.0f}),
.dimensions = {1, 2, 2, 8},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT16,
.zeroPoint = 0
}, { // param2
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({2}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::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<_Float16>({10.0f, 20.0f, 11.0f, 21.0f, 12.0f, 22.0f, 13.0f, 23.0f, 14.0f, 24.0f, 15.0f, 25.0f, 16.0f, 26.0f, 17.0f, 27.0f, 18.0f, 28.0f, 19.0f, 29.0f, 110.0f, 210.0f, 111.0f, 211.0f, 112.0f, 212.0f, 113.0f, 213.0f, 114.0f, 214.0f, 115.0f, 215.0f}),
.dimensions = {1, 4, 4, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT16,
.zeroPoint = 0
}},
.operations = {{
.inputs = {0, 1, 2},
.outputs = {3},
.type = TestOperationType::DEPTH_TO_SPACE
}},
.outputIndexes = {3}
},
.minSupportedVersion = TestHalVersion::V1_2,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nhwc_float16_3 = TestModelManager::get().add("depth_to_space_v1_2_nhwc_float16_3", get_test_model_nhwc_float16_3());
} // namespace generated_tests::depth_to_space_v1_2
namespace generated_tests::depth_to_space_v1_2 {
const TestModel& get_test_model_nhwc_float16_all_inputs_as_internal_3() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {4},
.operands = {{ // op12
.channelQuant = {},
.data = TestBuffer::createFromVector<_Float16>({}),
.dimensions = {1, 2, 2, 8},
.isIgnored = false,
.lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT16,
.zeroPoint = 0
}, { // param2
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({2}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::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<_Float16>({10.0f, 20.0f, 11.0f, 21.0f, 12.0f, 22.0f, 13.0f, 23.0f, 14.0f, 24.0f, 15.0f, 25.0f, 16.0f, 26.0f, 17.0f, 27.0f, 18.0f, 28.0f, 19.0f, 29.0f, 110.0f, 210.0f, 111.0f, 211.0f, 112.0f, 212.0f, 113.0f, 213.0f, 114.0f, 214.0f, 115.0f, 215.0f}),
.dimensions = {1, 4, 4, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT16,
.zeroPoint = 0
}, { // op12_new
.channelQuant = {},
.data = TestBuffer::createFromVector<_Float16>({10.0f, 20.0f, 11.0f, 21.0f, 14.0f, 24.0f, 15.0f, 25.0f, 12.0f, 22.0f, 13.0f, 23.0f, 16.0f, 26.0f, 17.0f, 27.0f, 18.0f, 28.0f, 19.0f, 29.0f, 112.0f, 212.0f, 113.0f, 213.0f, 110.0f, 210.0f, 111.0f, 211.0f, 114.0f, 214.0f, 115.0f, 215.0f}),
.dimensions = {1, 2, 2, 8},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT16,
.zeroPoint = 0
}, { // placeholder18
.channelQuant = {},
.data = TestBuffer::createFromVector<_Float16>({0.0f}),
.dimensions = {1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT16,
.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 = {4, 5, 6},
.outputs = {0},
.type = TestOperationType::ADD
}, {
.inputs = {0, 1, 2},
.outputs = {3},
.type = TestOperationType::DEPTH_TO_SPACE
}},
.outputIndexes = {3}
},
.minSupportedVersion = TestHalVersion::V1_2,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nhwc_float16_all_inputs_as_internal_3 = TestModelManager::get().add("depth_to_space_v1_2_nhwc_float16_all_inputs_as_internal_3", get_test_model_nhwc_float16_all_inputs_as_internal_3());
} // namespace generated_tests::depth_to_space_v1_2
namespace generated_tests::depth_to_space_v1_2 {
const TestModel& get_test_model_nhwc_quant8_3() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {0},
.operands = {{ // op12
.channelQuant = {},
.data = TestBuffer::createFromVector<uint8_t>({10, 20, 11, 21, 14, 24, 15, 25, 12, 22, 13, 23, 16, 26, 17, 27, 18, 28, 19, 29, 112, 212, 113, 213, 110, 210, 111, 211, 114, 214, 115, 215}),
.dimensions = {1, 2, 2, 8},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 1.0f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM,
.zeroPoint = 0
}, { // param2
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({2}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::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<uint8_t>({10, 20, 11, 21, 12, 22, 13, 23, 14, 24, 15, 25, 16, 26, 17, 27, 18, 28, 19, 29, 110, 210, 111, 211, 112, 212, 113, 213, 114, 214, 115, 215}),
.dimensions = {1, 4, 4, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 1.0f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM,
.zeroPoint = 0
}},
.operations = {{
.inputs = {0, 1, 2},
.outputs = {3},
.type = TestOperationType::DEPTH_TO_SPACE
}},
.outputIndexes = {3}
},
.minSupportedVersion = TestHalVersion::V1_0,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nhwc_quant8_3 = TestModelManager::get().add("depth_to_space_v1_2_nhwc_quant8_3", get_test_model_nhwc_quant8_3());
} // namespace generated_tests::depth_to_space_v1_2
namespace generated_tests::depth_to_space_v1_2 {
const TestModel& get_test_model_nhwc_quant8_all_inputs_as_internal_3() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {4},
.operands = {{ // op12
.channelQuant = {},
.data = TestBuffer::createFromVector<uint8_t>({}),
.dimensions = {1, 2, 2, 8},
.isIgnored = false,
.lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
.numberOfConsumers = 1,
.scale = 1.0f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM,
.zeroPoint = 0
}, { // param2
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({2}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::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<uint8_t>({10, 20, 11, 21, 12, 22, 13, 23, 14, 24, 15, 25, 16, 26, 17, 27, 18, 28, 19, 29, 110, 210, 111, 211, 112, 212, 113, 213, 114, 214, 115, 215}),
.dimensions = {1, 4, 4, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 1.0f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM,
.zeroPoint = 0
}, { // op12_new
.channelQuant = {},
.data = TestBuffer::createFromVector<uint8_t>({10, 20, 11, 21, 14, 24, 15, 25, 12, 22, 13, 23, 16, 26, 17, 27, 18, 28, 19, 29, 112, 212, 113, 213, 110, 210, 111, 211, 114, 214, 115, 215}),
.dimensions = {1, 2, 2, 8},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 1.0f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM,
.zeroPoint = 0
}, { // placeholder19
.channelQuant = {},
.data = TestBuffer::createFromVector<uint8_t>({0}),
.dimensions = {1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 1.0f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM,
.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 = {4, 5, 6},
.outputs = {0},
.type = TestOperationType::ADD
}, {
.inputs = {0, 1, 2},
.outputs = {3},
.type = TestOperationType::DEPTH_TO_SPACE
}},
.outputIndexes = {3}
},
.minSupportedVersion = TestHalVersion::V1_0,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nhwc_quant8_all_inputs_as_internal_3 = TestModelManager::get().add("depth_to_space_v1_2_nhwc_quant8_all_inputs_as_internal_3", get_test_model_nhwc_quant8_all_inputs_as_internal_3());
} // namespace generated_tests::depth_to_space_v1_2
namespace generated_tests::depth_to_space_v1_2 {
const TestModel& get_test_model_nchw_3() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {0},
.operands = {{ // op12
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({10.0f, 12.0f, 18.0f, 110.0f, 20.0f, 22.0f, 28.0f, 210.0f, 11.0f, 13.0f, 19.0f, 111.0f, 21.0f, 23.0f, 29.0f, 211.0f, 14.0f, 16.0f, 112.0f, 114.0f, 24.0f, 26.0f, 212.0f, 214.0f, 15.0f, 17.0f, 113.0f, 115.0f, 25.0f, 27.0f, 213.0f, 215.0f}),
.dimensions = {1, 8, 2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // param2
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({2}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::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<float>({10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f, 18.0f, 19.0f, 110.0f, 111.0f, 112.0f, 113.0f, 114.0f, 115.0f, 20.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f, 210.0f, 211.0f, 212.0f, 213.0f, 214.0f, 215.0f}),
.dimensions = {1, 2, 4, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}},
.operations = {{
.inputs = {0, 1, 2},
.outputs = {3},
.type = TestOperationType::DEPTH_TO_SPACE
}},
.outputIndexes = {3}
},
.minSupportedVersion = TestHalVersion::V1_2,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nchw_3 = TestModelManager::get().add("depth_to_space_v1_2_nchw_3", get_test_model_nchw_3());
} // namespace generated_tests::depth_to_space_v1_2
namespace generated_tests::depth_to_space_v1_2 {
const TestModel& get_test_model_nchw_all_inputs_as_internal_3() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {4},
.operands = {{ // op12
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({}),
.dimensions = {1, 8, 2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // param2
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({2}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::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<float>({10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f, 18.0f, 19.0f, 110.0f, 111.0f, 112.0f, 113.0f, 114.0f, 115.0f, 20.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f, 210.0f, 211.0f, 212.0f, 213.0f, 214.0f, 215.0f}),
.dimensions = {1, 2, 4, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // op12_new
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({10.0f, 12.0f, 18.0f, 110.0f, 20.0f, 22.0f, 28.0f, 210.0f, 11.0f, 13.0f, 19.0f, 111.0f, 21.0f, 23.0f, 29.0f, 211.0f, 14.0f, 16.0f, 112.0f, 114.0f, 24.0f, 26.0f, 212.0f, 214.0f, 15.0f, 17.0f, 113.0f, 115.0f, 25.0f, 27.0f, 213.0f, 215.0f}),
.dimensions = {1, 8, 2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // placeholder20
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({0.0f}),
.dimensions = {1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.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 = {4, 5, 6},
.outputs = {0},
.type = TestOperationType::ADD
}, {
.inputs = {0, 1, 2},
.outputs = {3},
.type = TestOperationType::DEPTH_TO_SPACE
}},
.outputIndexes = {3}
},
.minSupportedVersion = TestHalVersion::V1_2,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nchw_all_inputs_as_internal_3 = TestModelManager::get().add("depth_to_space_v1_2_nchw_all_inputs_as_internal_3", get_test_model_nchw_all_inputs_as_internal_3());
} // namespace generated_tests::depth_to_space_v1_2
namespace generated_tests::depth_to_space_v1_2 {
const TestModel& get_test_model_nchw_relaxed_3() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = true,
.main = {
.inputIndexes = {0},
.operands = {{ // op12
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({10.0f, 12.0f, 18.0f, 110.0f, 20.0f, 22.0f, 28.0f, 210.0f, 11.0f, 13.0f, 19.0f, 111.0f, 21.0f, 23.0f, 29.0f, 211.0f, 14.0f, 16.0f, 112.0f, 114.0f, 24.0f, 26.0f, 212.0f, 214.0f, 15.0f, 17.0f, 113.0f, 115.0f, 25.0f, 27.0f, 213.0f, 215.0f}),
.dimensions = {1, 8, 2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // param2
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({2}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::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<float>({10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f, 18.0f, 19.0f, 110.0f, 111.0f, 112.0f, 113.0f, 114.0f, 115.0f, 20.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f, 210.0f, 211.0f, 212.0f, 213.0f, 214.0f, 215.0f}),
.dimensions = {1, 2, 4, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}},
.operations = {{
.inputs = {0, 1, 2},
.outputs = {3},
.type = TestOperationType::DEPTH_TO_SPACE
}},
.outputIndexes = {3}
},
.minSupportedVersion = TestHalVersion::UNKNOWN,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nchw_relaxed_3 = TestModelManager::get().add("depth_to_space_v1_2_nchw_relaxed_3", get_test_model_nchw_relaxed_3());
} // namespace generated_tests::depth_to_space_v1_2
namespace generated_tests::depth_to_space_v1_2 {
const TestModel& get_test_model_nchw_relaxed_all_inputs_as_internal_3() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = true,
.main = {
.inputIndexes = {4},
.operands = {{ // op12
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({}),
.dimensions = {1, 8, 2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // param2
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({2}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::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<float>({10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f, 18.0f, 19.0f, 110.0f, 111.0f, 112.0f, 113.0f, 114.0f, 115.0f, 20.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f, 210.0f, 211.0f, 212.0f, 213.0f, 214.0f, 215.0f}),
.dimensions = {1, 2, 4, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // op12_new
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({10.0f, 12.0f, 18.0f, 110.0f, 20.0f, 22.0f, 28.0f, 210.0f, 11.0f, 13.0f, 19.0f, 111.0f, 21.0f, 23.0f, 29.0f, 211.0f, 14.0f, 16.0f, 112.0f, 114.0f, 24.0f, 26.0f, 212.0f, 214.0f, 15.0f, 17.0f, 113.0f, 115.0f, 25.0f, 27.0f, 213.0f, 215.0f}),
.dimensions = {1, 8, 2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.zeroPoint = 0
}, { // placeholder21
.channelQuant = {},
.data = TestBuffer::createFromVector<float>({0.0f}),
.dimensions = {1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT32,
.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 = {4, 5, 6},
.outputs = {0},
.type = TestOperationType::ADD
}, {
.inputs = {0, 1, 2},
.outputs = {3},
.type = TestOperationType::DEPTH_TO_SPACE
}},
.outputIndexes = {3}
},
.minSupportedVersion = TestHalVersion::UNKNOWN,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nchw_relaxed_all_inputs_as_internal_3 = TestModelManager::get().add("depth_to_space_v1_2_nchw_relaxed_all_inputs_as_internal_3", get_test_model_nchw_relaxed_all_inputs_as_internal_3());
} // namespace generated_tests::depth_to_space_v1_2
namespace generated_tests::depth_to_space_v1_2 {
const TestModel& get_test_model_nchw_float16_3() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {0},
.operands = {{ // op12
.channelQuant = {},
.data = TestBuffer::createFromVector<_Float16>({10.0f, 12.0f, 18.0f, 110.0f, 20.0f, 22.0f, 28.0f, 210.0f, 11.0f, 13.0f, 19.0f, 111.0f, 21.0f, 23.0f, 29.0f, 211.0f, 14.0f, 16.0f, 112.0f, 114.0f, 24.0f, 26.0f, 212.0f, 214.0f, 15.0f, 17.0f, 113.0f, 115.0f, 25.0f, 27.0f, 213.0f, 215.0f}),
.dimensions = {1, 8, 2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT16,
.zeroPoint = 0
}, { // param2
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({2}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::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<_Float16>({10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f, 18.0f, 19.0f, 110.0f, 111.0f, 112.0f, 113.0f, 114.0f, 115.0f, 20.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f, 210.0f, 211.0f, 212.0f, 213.0f, 214.0f, 215.0f}),
.dimensions = {1, 2, 4, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT16,
.zeroPoint = 0
}},
.operations = {{
.inputs = {0, 1, 2},
.outputs = {3},
.type = TestOperationType::DEPTH_TO_SPACE
}},
.outputIndexes = {3}
},
.minSupportedVersion = TestHalVersion::V1_2,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nchw_float16_3 = TestModelManager::get().add("depth_to_space_v1_2_nchw_float16_3", get_test_model_nchw_float16_3());
} // namespace generated_tests::depth_to_space_v1_2
namespace generated_tests::depth_to_space_v1_2 {
const TestModel& get_test_model_nchw_float16_all_inputs_as_internal_3() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {4},
.operands = {{ // op12
.channelQuant = {},
.data = TestBuffer::createFromVector<_Float16>({}),
.dimensions = {1, 8, 2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT16,
.zeroPoint = 0
}, { // param2
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({2}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::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<_Float16>({10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f, 17.0f, 18.0f, 19.0f, 110.0f, 111.0f, 112.0f, 113.0f, 114.0f, 115.0f, 20.0f, 21.0f, 22.0f, 23.0f, 24.0f, 25.0f, 26.0f, 27.0f, 28.0f, 29.0f, 210.0f, 211.0f, 212.0f, 213.0f, 214.0f, 215.0f}),
.dimensions = {1, 2, 4, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT16,
.zeroPoint = 0
}, { // op12_new
.channelQuant = {},
.data = TestBuffer::createFromVector<_Float16>({10.0f, 12.0f, 18.0f, 110.0f, 20.0f, 22.0f, 28.0f, 210.0f, 11.0f, 13.0f, 19.0f, 111.0f, 21.0f, 23.0f, 29.0f, 211.0f, 14.0f, 16.0f, 112.0f, 114.0f, 24.0f, 26.0f, 212.0f, 214.0f, 15.0f, 17.0f, 113.0f, 115.0f, 25.0f, 27.0f, 213.0f, 215.0f}),
.dimensions = {1, 8, 2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT16,
.zeroPoint = 0
}, { // placeholder22
.channelQuant = {},
.data = TestBuffer::createFromVector<_Float16>({0.0f}),
.dimensions = {1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::TENSOR_FLOAT16,
.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 = {4, 5, 6},
.outputs = {0},
.type = TestOperationType::ADD
}, {
.inputs = {0, 1, 2},
.outputs = {3},
.type = TestOperationType::DEPTH_TO_SPACE
}},
.outputIndexes = {3}
},
.minSupportedVersion = TestHalVersion::V1_2,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nchw_float16_all_inputs_as_internal_3 = TestModelManager::get().add("depth_to_space_v1_2_nchw_float16_all_inputs_as_internal_3", get_test_model_nchw_float16_all_inputs_as_internal_3());
} // namespace generated_tests::depth_to_space_v1_2
namespace generated_tests::depth_to_space_v1_2 {
const TestModel& get_test_model_nchw_quant8_3() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {0},
.operands = {{ // op12
.channelQuant = {},
.data = TestBuffer::createFromVector<uint8_t>({10, 12, 18, 110, 20, 22, 28, 210, 11, 13, 19, 111, 21, 23, 29, 211, 14, 16, 112, 114, 24, 26, 212, 214, 15, 17, 113, 115, 25, 27, 213, 215}),
.dimensions = {1, 8, 2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 1.0f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM,
.zeroPoint = 0
}, { // param2
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({2}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::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<uint8_t>({10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 110, 111, 112, 113, 114, 115, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 210, 211, 212, 213, 214, 215}),
.dimensions = {1, 2, 4, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 1.0f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM,
.zeroPoint = 0
}},
.operations = {{
.inputs = {0, 1, 2},
.outputs = {3},
.type = TestOperationType::DEPTH_TO_SPACE
}},
.outputIndexes = {3}
},
.minSupportedVersion = TestHalVersion::V1_2,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nchw_quant8_3 = TestModelManager::get().add("depth_to_space_v1_2_nchw_quant8_3", get_test_model_nchw_quant8_3());
} // namespace generated_tests::depth_to_space_v1_2
namespace generated_tests::depth_to_space_v1_2 {
const TestModel& get_test_model_nchw_quant8_all_inputs_as_internal_3() {
static TestModel model = {
.expectFailure = false,
.expectedMultinomialDistributionTolerance = 0,
.isRelaxed = false,
.main = {
.inputIndexes = {4},
.operands = {{ // op12
.channelQuant = {},
.data = TestBuffer::createFromVector<uint8_t>({}),
.dimensions = {1, 8, 2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE,
.numberOfConsumers = 1,
.scale = 1.0f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM,
.zeroPoint = 0
}, { // param2
.channelQuant = {},
.data = TestBuffer::createFromVector<int32_t>({2}),
.dimensions = {},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 0.0f,
.type = TestOperandType::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<uint8_t>({10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 110, 111, 112, 113, 114, 115, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 210, 211, 212, 213, 214, 215}),
.dimensions = {1, 2, 4, 4},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT,
.numberOfConsumers = 0,
.scale = 1.0f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM,
.zeroPoint = 0
}, { // op12_new
.channelQuant = {},
.data = TestBuffer::createFromVector<uint8_t>({10, 12, 18, 110, 20, 22, 28, 210, 11, 13, 19, 111, 21, 23, 29, 211, 14, 16, 112, 114, 24, 26, 212, 214, 15, 17, 113, 115, 25, 27, 213, 215}),
.dimensions = {1, 8, 2, 2},
.isIgnored = false,
.lifetime = TestOperandLifeTime::SUBGRAPH_INPUT,
.numberOfConsumers = 1,
.scale = 1.0f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM,
.zeroPoint = 0
}, { // placeholder23
.channelQuant = {},
.data = TestBuffer::createFromVector<uint8_t>({0}),
.dimensions = {1},
.isIgnored = false,
.lifetime = TestOperandLifeTime::CONSTANT_COPY,
.numberOfConsumers = 1,
.scale = 1.0f,
.type = TestOperandType::TENSOR_QUANT8_ASYMM,
.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 = {4, 5, 6},
.outputs = {0},
.type = TestOperationType::ADD
}, {
.inputs = {0, 1, 2},
.outputs = {3},
.type = TestOperationType::DEPTH_TO_SPACE
}},
.outputIndexes = {3}
},
.minSupportedVersion = TestHalVersion::V1_2,
.referenced = {}
};
return model;
}
const auto dummy_test_model_nchw_quant8_all_inputs_as_internal_3 = TestModelManager::get().add("depth_to_space_v1_2_nchw_quant8_all_inputs_as_internal_3", get_test_model_nchw_quant8_all_inputs_as_internal_3());
} // namespace generated_tests::depth_to_space_v1_2