// Generated from l2_normalization_axis.mod.py // DO NOT EDIT // clang-format off #include "TestHarness.h" using namespace test_helper; // NOLINT(google-build-using-namespace) namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim4_axis0() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3, 2, 2, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 8.0f, 12.0f, 9.0f, 12.0f, 20.0f, 16.0f, 3.0f, 0.0f, 6.0f, 0.0f, 12.0f, 15.0f, 9.0f, 15.0f, 4.0f, 4.0f, 0.0f, 9.0f, 20.0f, 16.0f, 12.0f, 12.0f}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3, 2, 2, 2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.8f, 0.8f, 0.36f, 0.48f, 0.8f, 0.64f, 0.6f, 0.0f, 0.6f, 0.0f, 0.48f, 0.6f, 0.36f, 0.6f, 0.8f, 0.8f, 0.0f, 0.6f, 0.8f, 0.64f, 0.48f, 0.48f}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim4_axis0 = TestModelManager::get().add("l2_normalization_axis_dim4_axis0", get_test_model_dim4_axis0()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim4_axis0_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3, 2, 2, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3, 2, 2, 2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.8f, 0.8f, 0.36f, 0.48f, 0.8f, 0.64f, 0.6f, 0.0f, 0.6f, 0.0f, 0.48f, 0.6f, 0.36f, 0.6f, 0.8f, 0.8f, 0.0f, 0.6f, 0.8f, 0.64f, 0.48f, 0.48f}) }, { // op1_new .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3, 2, 2, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 8.0f, 12.0f, 9.0f, 12.0f, 20.0f, 16.0f, 3.0f, 0.0f, 6.0f, 0.0f, 12.0f, 15.0f, 9.0f, 15.0f, 4.0f, 4.0f, 0.0f, 9.0f, 20.0f, 16.0f, 12.0f, 12.0f}) }, { // placeholder .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f}) }, { // param .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim4_axis0_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim4_axis0_all_inputs_as_internal", get_test_model_dim4_axis0_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim4_axis0_relaxed() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3, 2, 2, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 8.0f, 12.0f, 9.0f, 12.0f, 20.0f, 16.0f, 3.0f, 0.0f, 6.0f, 0.0f, 12.0f, 15.0f, 9.0f, 15.0f, 4.0f, 4.0f, 0.0f, 9.0f, 20.0f, 16.0f, 12.0f, 12.0f}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3, 2, 2, 2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.8f, 0.8f, 0.36f, 0.48f, 0.8f, 0.64f, 0.6f, 0.0f, 0.6f, 0.0f, 0.48f, 0.6f, 0.36f, 0.6f, 0.8f, 0.8f, 0.0f, 0.6f, 0.8f, 0.64f, 0.48f, 0.48f}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = true, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::UNKNOWN }; return model; } const auto dummy_test_model_dim4_axis0_relaxed = TestModelManager::get().add("l2_normalization_axis_dim4_axis0_relaxed", get_test_model_dim4_axis0_relaxed()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim4_axis0_relaxed_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3, 2, 2, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3, 2, 2, 2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.8f, 0.8f, 0.36f, 0.48f, 0.8f, 0.64f, 0.6f, 0.0f, 0.6f, 0.0f, 0.48f, 0.6f, 0.36f, 0.6f, 0.8f, 0.8f, 0.0f, 0.6f, 0.8f, 0.64f, 0.48f, 0.48f}) }, { // op1_new .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3, 2, 2, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 8.0f, 12.0f, 9.0f, 12.0f, 20.0f, 16.0f, 3.0f, 0.0f, 6.0f, 0.0f, 12.0f, 15.0f, 9.0f, 15.0f, 4.0f, 4.0f, 0.0f, 9.0f, 20.0f, 16.0f, 12.0f, 12.0f}) }, { // placeholder1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f}) }, { // param1 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = true, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::UNKNOWN }; return model; } const auto dummy_test_model_dim4_axis0_relaxed_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim4_axis0_relaxed_all_inputs_as_internal", get_test_model_dim4_axis0_relaxed_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim4_axis0_float16() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {3, 2, 2, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 3.0f, 8.0f, 12.0f, 9.0f, 12.0f, 20.0f, 16.0f, 3.0f, 0.0f, 6.0f, 0.0f, 12.0f, 15.0f, 9.0f, 15.0f, 4.0f, 4.0f, 0.0f, 9.0f, 20.0f, 16.0f, 12.0f, 12.0f}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {3, 2, 2, 2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 0.6000000238418579f, 0.800000011920929f, 0.800000011920929f, 0.36000001430511475f, 0.47999998927116394f, 0.800000011920929f, 0.6399999856948853f, 0.6000000238418579f, 0.0f, 0.6000000238418579f, 0.0f, 0.47999998927116394f, 0.6000000238418579f, 0.36000001430511475f, 0.6000000238418579f, 0.800000011920929f, 0.800000011920929f, 0.0f, 0.6000000238418579f, 0.800000011920929f, 0.6399999856948853f, 0.47999998927116394f, 0.47999998927116394f}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim4_axis0_float16 = TestModelManager::get().add("l2_normalization_axis_dim4_axis0_float16", get_test_model_dim4_axis0_float16()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim4_axis0_float16_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {3, 2, 2, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {3, 2, 2, 2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 0.6000000238418579f, 0.800000011920929f, 0.800000011920929f, 0.36000001430511475f, 0.47999998927116394f, 0.800000011920929f, 0.6399999856948853f, 0.6000000238418579f, 0.0f, 0.6000000238418579f, 0.0f, 0.47999998927116394f, 0.6000000238418579f, 0.36000001430511475f, 0.6000000238418579f, 0.800000011920929f, 0.800000011920929f, 0.0f, 0.6000000238418579f, 0.800000011920929f, 0.6399999856948853f, 0.47999998927116394f, 0.47999998927116394f}) }, { // op1_new .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {3, 2, 2, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 3.0f, 8.0f, 12.0f, 9.0f, 12.0f, 20.0f, 16.0f, 3.0f, 0.0f, 6.0f, 0.0f, 12.0f, 15.0f, 9.0f, 15.0f, 4.0f, 4.0f, 0.0f, 9.0f, 20.0f, 16.0f, 12.0f, 12.0f}) }, { // placeholder2 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f}) }, { // param2 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim4_axis0_float16_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim4_axis0_float16_all_inputs_as_internal", get_test_model_dim4_axis0_float16_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim4_axis0_quant8() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {3, 2, 2, 2}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({32, 62, 112, 152, 122, 152, 232, 192, 62, 32, 92, 32, 152, 182, 122, 182, 72, 72, 32, 122, 232, 192, 152, 152}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }, { // op2 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {3, 2, 2, 2}, .numberOfConsumers = 0, .scale = 0.0078125f, .zeroPoint = 128, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({128, 205, 230, 230, 174, 189, 230, 210, 205, 128, 205, 128, 189, 205, 174, 205, 230, 230, 128, 205, 230, 210, 189, 189}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim4_axis0_quant8 = TestModelManager::get().add("l2_normalization_axis_dim4_axis0_quant8", get_test_model_dim4_axis0_quant8()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim4_axis0_quant8_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {3, 2, 2, 2}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }, { // op2 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {3, 2, 2, 2}, .numberOfConsumers = 0, .scale = 0.0078125f, .zeroPoint = 128, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({128, 205, 230, 230, 174, 189, 230, 210, 205, 128, 205, 128, 189, 205, 174, 205, 230, 230, 128, 205, 230, 210, 189, 189}) }, { // op1_new .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {3, 2, 2, 2}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({32, 62, 112, 152, 122, 152, 232, 192, 62, 32, 92, 32, 152, 182, 122, 182, 72, 72, 32, 122, 232, 192, 152, 152}) }, { // placeholder3 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({32}) }, { // param3 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim4_axis0_quant8_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim4_axis0_quant8_all_inputs_as_internal", get_test_model_dim4_axis0_quant8_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim4_axis0_neg() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3, 2, 2, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 8.0f, 12.0f, 9.0f, 12.0f, 20.0f, 16.0f, 3.0f, 0.0f, 6.0f, 0.0f, 12.0f, 15.0f, 9.0f, 15.0f, 4.0f, 4.0f, 0.0f, 9.0f, 20.0f, 16.0f, 12.0f, 12.0f}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-4}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3, 2, 2, 2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.8f, 0.8f, 0.36f, 0.48f, 0.8f, 0.64f, 0.6f, 0.0f, 0.6f, 0.0f, 0.48f, 0.6f, 0.36f, 0.6f, 0.8f, 0.8f, 0.0f, 0.6f, 0.8f, 0.64f, 0.48f, 0.48f}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim4_axis0_neg = TestModelManager::get().add("l2_normalization_axis_dim4_axis0_neg", get_test_model_dim4_axis0_neg()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim4_axis0_neg_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3, 2, 2, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-4}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3, 2, 2, 2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.8f, 0.8f, 0.36f, 0.48f, 0.8f, 0.64f, 0.6f, 0.0f, 0.6f, 0.0f, 0.48f, 0.6f, 0.36f, 0.6f, 0.8f, 0.8f, 0.0f, 0.6f, 0.8f, 0.64f, 0.48f, 0.48f}) }, { // op1_new .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3, 2, 2, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 8.0f, 12.0f, 9.0f, 12.0f, 20.0f, 16.0f, 3.0f, 0.0f, 6.0f, 0.0f, 12.0f, 15.0f, 9.0f, 15.0f, 4.0f, 4.0f, 0.0f, 9.0f, 20.0f, 16.0f, 12.0f, 12.0f}) }, { // placeholder4 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f}) }, { // param4 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim4_axis0_neg_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim4_axis0_neg_all_inputs_as_internal", get_test_model_dim4_axis0_neg_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim4_axis0_neg_relaxed() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3, 2, 2, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 8.0f, 12.0f, 9.0f, 12.0f, 20.0f, 16.0f, 3.0f, 0.0f, 6.0f, 0.0f, 12.0f, 15.0f, 9.0f, 15.0f, 4.0f, 4.0f, 0.0f, 9.0f, 20.0f, 16.0f, 12.0f, 12.0f}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-4}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3, 2, 2, 2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.8f, 0.8f, 0.36f, 0.48f, 0.8f, 0.64f, 0.6f, 0.0f, 0.6f, 0.0f, 0.48f, 0.6f, 0.36f, 0.6f, 0.8f, 0.8f, 0.0f, 0.6f, 0.8f, 0.64f, 0.48f, 0.48f}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = true, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::UNKNOWN }; return model; } const auto dummy_test_model_dim4_axis0_neg_relaxed = TestModelManager::get().add("l2_normalization_axis_dim4_axis0_neg_relaxed", get_test_model_dim4_axis0_neg_relaxed()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim4_axis0_neg_relaxed_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3, 2, 2, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-4}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3, 2, 2, 2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.8f, 0.8f, 0.36f, 0.48f, 0.8f, 0.64f, 0.6f, 0.0f, 0.6f, 0.0f, 0.48f, 0.6f, 0.36f, 0.6f, 0.8f, 0.8f, 0.0f, 0.6f, 0.8f, 0.64f, 0.48f, 0.48f}) }, { // op1_new .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3, 2, 2, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 8.0f, 12.0f, 9.0f, 12.0f, 20.0f, 16.0f, 3.0f, 0.0f, 6.0f, 0.0f, 12.0f, 15.0f, 9.0f, 15.0f, 4.0f, 4.0f, 0.0f, 9.0f, 20.0f, 16.0f, 12.0f, 12.0f}) }, { // placeholder5 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f}) }, { // param5 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = true, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::UNKNOWN }; return model; } const auto dummy_test_model_dim4_axis0_neg_relaxed_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim4_axis0_neg_relaxed_all_inputs_as_internal", get_test_model_dim4_axis0_neg_relaxed_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim4_axis0_neg_float16() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {3, 2, 2, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 3.0f, 8.0f, 12.0f, 9.0f, 12.0f, 20.0f, 16.0f, 3.0f, 0.0f, 6.0f, 0.0f, 12.0f, 15.0f, 9.0f, 15.0f, 4.0f, 4.0f, 0.0f, 9.0f, 20.0f, 16.0f, 12.0f, 12.0f}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-4}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {3, 2, 2, 2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 0.6000000238418579f, 0.800000011920929f, 0.800000011920929f, 0.36000001430511475f, 0.47999998927116394f, 0.800000011920929f, 0.6399999856948853f, 0.6000000238418579f, 0.0f, 0.6000000238418579f, 0.0f, 0.47999998927116394f, 0.6000000238418579f, 0.36000001430511475f, 0.6000000238418579f, 0.800000011920929f, 0.800000011920929f, 0.0f, 0.6000000238418579f, 0.800000011920929f, 0.6399999856948853f, 0.47999998927116394f, 0.47999998927116394f}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim4_axis0_neg_float16 = TestModelManager::get().add("l2_normalization_axis_dim4_axis0_neg_float16", get_test_model_dim4_axis0_neg_float16()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim4_axis0_neg_float16_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {3, 2, 2, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-4}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {3, 2, 2, 2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 0.6000000238418579f, 0.800000011920929f, 0.800000011920929f, 0.36000001430511475f, 0.47999998927116394f, 0.800000011920929f, 0.6399999856948853f, 0.6000000238418579f, 0.0f, 0.6000000238418579f, 0.0f, 0.47999998927116394f, 0.6000000238418579f, 0.36000001430511475f, 0.6000000238418579f, 0.800000011920929f, 0.800000011920929f, 0.0f, 0.6000000238418579f, 0.800000011920929f, 0.6399999856948853f, 0.47999998927116394f, 0.47999998927116394f}) }, { // op1_new .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {3, 2, 2, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 3.0f, 8.0f, 12.0f, 9.0f, 12.0f, 20.0f, 16.0f, 3.0f, 0.0f, 6.0f, 0.0f, 12.0f, 15.0f, 9.0f, 15.0f, 4.0f, 4.0f, 0.0f, 9.0f, 20.0f, 16.0f, 12.0f, 12.0f}) }, { // placeholder6 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f}) }, { // param6 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim4_axis0_neg_float16_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim4_axis0_neg_float16_all_inputs_as_internal", get_test_model_dim4_axis0_neg_float16_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim4_axis0_neg_quant8() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {3, 2, 2, 2}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({32, 62, 112, 152, 122, 152, 232, 192, 62, 32, 92, 32, 152, 182, 122, 182, 72, 72, 32, 122, 232, 192, 152, 152}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-4}) }, { // op2 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {3, 2, 2, 2}, .numberOfConsumers = 0, .scale = 0.0078125f, .zeroPoint = 128, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({128, 205, 230, 230, 174, 189, 230, 210, 205, 128, 205, 128, 189, 205, 174, 205, 230, 230, 128, 205, 230, 210, 189, 189}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim4_axis0_neg_quant8 = TestModelManager::get().add("l2_normalization_axis_dim4_axis0_neg_quant8", get_test_model_dim4_axis0_neg_quant8()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim4_axis0_neg_quant8_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {3, 2, 2, 2}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-4}) }, { // op2 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {3, 2, 2, 2}, .numberOfConsumers = 0, .scale = 0.0078125f, .zeroPoint = 128, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({128, 205, 230, 230, 174, 189, 230, 210, 205, 128, 205, 128, 189, 205, 174, 205, 230, 230, 128, 205, 230, 210, 189, 189}) }, { // op1_new .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {3, 2, 2, 2}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({32, 62, 112, 152, 122, 152, 232, 192, 62, 32, 92, 32, 152, 182, 122, 182, 72, 72, 32, 122, 232, 192, 152, 152}) }, { // placeholder7 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({32}) }, { // param7 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim4_axis0_neg_quant8_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim4_axis0_neg_quant8_all_inputs_as_internal", get_test_model_dim4_axis0_neg_quant8_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim4_axis1() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 3, 2, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 8.0f, 12.0f, 3.0f, 0.0f, 6.0f, 0.0f, 4.0f, 4.0f, 0.0f, 9.0f, 9.0f, 12.0f, 20.0f, 16.0f, 12.0f, 15.0f, 9.0f, 15.0f, 20.0f, 16.0f, 12.0f, 12.0f}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({1}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 3, 2, 2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.8f, 0.8f, 0.6f, 0.0f, 0.6f, 0.0f, 0.8f, 0.8f, 0.0f, 0.6f, 0.36f, 0.48f, 0.8f, 0.64f, 0.48f, 0.6f, 0.36f, 0.6f, 0.8f, 0.64f, 0.48f, 0.48f}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim4_axis1 = TestModelManager::get().add("l2_normalization_axis_dim4_axis1", get_test_model_dim4_axis1()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim4_axis1_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 3, 2, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({1}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 3, 2, 2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.8f, 0.8f, 0.6f, 0.0f, 0.6f, 0.0f, 0.8f, 0.8f, 0.0f, 0.6f, 0.36f, 0.48f, 0.8f, 0.64f, 0.48f, 0.6f, 0.36f, 0.6f, 0.8f, 0.64f, 0.48f, 0.48f}) }, { // op1_new .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 3, 2, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 8.0f, 12.0f, 3.0f, 0.0f, 6.0f, 0.0f, 4.0f, 4.0f, 0.0f, 9.0f, 9.0f, 12.0f, 20.0f, 16.0f, 12.0f, 15.0f, 9.0f, 15.0f, 20.0f, 16.0f, 12.0f, 12.0f}) }, { // placeholder8 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f}) }, { // param8 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim4_axis1_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim4_axis1_all_inputs_as_internal", get_test_model_dim4_axis1_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim4_axis1_relaxed() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 3, 2, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 8.0f, 12.0f, 3.0f, 0.0f, 6.0f, 0.0f, 4.0f, 4.0f, 0.0f, 9.0f, 9.0f, 12.0f, 20.0f, 16.0f, 12.0f, 15.0f, 9.0f, 15.0f, 20.0f, 16.0f, 12.0f, 12.0f}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({1}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 3, 2, 2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.8f, 0.8f, 0.6f, 0.0f, 0.6f, 0.0f, 0.8f, 0.8f, 0.0f, 0.6f, 0.36f, 0.48f, 0.8f, 0.64f, 0.48f, 0.6f, 0.36f, 0.6f, 0.8f, 0.64f, 0.48f, 0.48f}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = true, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::UNKNOWN }; return model; } const auto dummy_test_model_dim4_axis1_relaxed = TestModelManager::get().add("l2_normalization_axis_dim4_axis1_relaxed", get_test_model_dim4_axis1_relaxed()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim4_axis1_relaxed_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 3, 2, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({1}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 3, 2, 2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.8f, 0.8f, 0.6f, 0.0f, 0.6f, 0.0f, 0.8f, 0.8f, 0.0f, 0.6f, 0.36f, 0.48f, 0.8f, 0.64f, 0.48f, 0.6f, 0.36f, 0.6f, 0.8f, 0.64f, 0.48f, 0.48f}) }, { // op1_new .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 3, 2, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 8.0f, 12.0f, 3.0f, 0.0f, 6.0f, 0.0f, 4.0f, 4.0f, 0.0f, 9.0f, 9.0f, 12.0f, 20.0f, 16.0f, 12.0f, 15.0f, 9.0f, 15.0f, 20.0f, 16.0f, 12.0f, 12.0f}) }, { // placeholder9 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f}) }, { // param9 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = true, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::UNKNOWN }; return model; } const auto dummy_test_model_dim4_axis1_relaxed_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim4_axis1_relaxed_all_inputs_as_internal", get_test_model_dim4_axis1_relaxed_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim4_axis1_float16() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {2, 3, 2, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 3.0f, 8.0f, 12.0f, 3.0f, 0.0f, 6.0f, 0.0f, 4.0f, 4.0f, 0.0f, 9.0f, 9.0f, 12.0f, 20.0f, 16.0f, 12.0f, 15.0f, 9.0f, 15.0f, 20.0f, 16.0f, 12.0f, 12.0f}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({1}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {2, 3, 2, 2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 0.6000000238418579f, 0.800000011920929f, 0.800000011920929f, 0.6000000238418579f, 0.0f, 0.6000000238418579f, 0.0f, 0.800000011920929f, 0.800000011920929f, 0.0f, 0.6000000238418579f, 0.36000001430511475f, 0.47999998927116394f, 0.800000011920929f, 0.6399999856948853f, 0.47999998927116394f, 0.6000000238418579f, 0.36000001430511475f, 0.6000000238418579f, 0.800000011920929f, 0.6399999856948853f, 0.47999998927116394f, 0.47999998927116394f}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim4_axis1_float16 = TestModelManager::get().add("l2_normalization_axis_dim4_axis1_float16", get_test_model_dim4_axis1_float16()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim4_axis1_float16_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {2, 3, 2, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({1}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {2, 3, 2, 2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 0.6000000238418579f, 0.800000011920929f, 0.800000011920929f, 0.6000000238418579f, 0.0f, 0.6000000238418579f, 0.0f, 0.800000011920929f, 0.800000011920929f, 0.0f, 0.6000000238418579f, 0.36000001430511475f, 0.47999998927116394f, 0.800000011920929f, 0.6399999856948853f, 0.47999998927116394f, 0.6000000238418579f, 0.36000001430511475f, 0.6000000238418579f, 0.800000011920929f, 0.6399999856948853f, 0.47999998927116394f, 0.47999998927116394f}) }, { // op1_new .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {2, 3, 2, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 3.0f, 8.0f, 12.0f, 3.0f, 0.0f, 6.0f, 0.0f, 4.0f, 4.0f, 0.0f, 9.0f, 9.0f, 12.0f, 20.0f, 16.0f, 12.0f, 15.0f, 9.0f, 15.0f, 20.0f, 16.0f, 12.0f, 12.0f}) }, { // placeholder10 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f}) }, { // param10 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim4_axis1_float16_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim4_axis1_float16_all_inputs_as_internal", get_test_model_dim4_axis1_float16_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim4_axis1_quant8() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {2, 3, 2, 2}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({32, 62, 112, 152, 62, 32, 92, 32, 72, 72, 32, 122, 122, 152, 232, 192, 152, 182, 122, 182, 232, 192, 152, 152}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({1}) }, { // op2 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {2, 3, 2, 2}, .numberOfConsumers = 0, .scale = 0.0078125f, .zeroPoint = 128, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({128, 205, 230, 230, 205, 128, 205, 128, 230, 230, 128, 205, 174, 189, 230, 210, 189, 205, 174, 205, 230, 210, 189, 189}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim4_axis1_quant8 = TestModelManager::get().add("l2_normalization_axis_dim4_axis1_quant8", get_test_model_dim4_axis1_quant8()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim4_axis1_quant8_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {2, 3, 2, 2}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({1}) }, { // op2 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {2, 3, 2, 2}, .numberOfConsumers = 0, .scale = 0.0078125f, .zeroPoint = 128, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({128, 205, 230, 230, 205, 128, 205, 128, 230, 230, 128, 205, 174, 189, 230, 210, 189, 205, 174, 205, 230, 210, 189, 189}) }, { // op1_new .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {2, 3, 2, 2}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({32, 62, 112, 152, 62, 32, 92, 32, 72, 72, 32, 122, 122, 152, 232, 192, 152, 182, 122, 182, 232, 192, 152, 152}) }, { // placeholder11 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({32}) }, { // param11 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim4_axis1_quant8_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim4_axis1_quant8_all_inputs_as_internal", get_test_model_dim4_axis1_quant8_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim4_axis1_neg() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 3, 2, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 8.0f, 12.0f, 3.0f, 0.0f, 6.0f, 0.0f, 4.0f, 4.0f, 0.0f, 9.0f, 9.0f, 12.0f, 20.0f, 16.0f, 12.0f, 15.0f, 9.0f, 15.0f, 20.0f, 16.0f, 12.0f, 12.0f}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-3}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 3, 2, 2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.8f, 0.8f, 0.6f, 0.0f, 0.6f, 0.0f, 0.8f, 0.8f, 0.0f, 0.6f, 0.36f, 0.48f, 0.8f, 0.64f, 0.48f, 0.6f, 0.36f, 0.6f, 0.8f, 0.64f, 0.48f, 0.48f}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim4_axis1_neg = TestModelManager::get().add("l2_normalization_axis_dim4_axis1_neg", get_test_model_dim4_axis1_neg()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim4_axis1_neg_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 3, 2, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-3}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 3, 2, 2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.8f, 0.8f, 0.6f, 0.0f, 0.6f, 0.0f, 0.8f, 0.8f, 0.0f, 0.6f, 0.36f, 0.48f, 0.8f, 0.64f, 0.48f, 0.6f, 0.36f, 0.6f, 0.8f, 0.64f, 0.48f, 0.48f}) }, { // op1_new .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 3, 2, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 8.0f, 12.0f, 3.0f, 0.0f, 6.0f, 0.0f, 4.0f, 4.0f, 0.0f, 9.0f, 9.0f, 12.0f, 20.0f, 16.0f, 12.0f, 15.0f, 9.0f, 15.0f, 20.0f, 16.0f, 12.0f, 12.0f}) }, { // placeholder12 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f}) }, { // param12 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim4_axis1_neg_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim4_axis1_neg_all_inputs_as_internal", get_test_model_dim4_axis1_neg_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim4_axis1_neg_relaxed() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 3, 2, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 8.0f, 12.0f, 3.0f, 0.0f, 6.0f, 0.0f, 4.0f, 4.0f, 0.0f, 9.0f, 9.0f, 12.0f, 20.0f, 16.0f, 12.0f, 15.0f, 9.0f, 15.0f, 20.0f, 16.0f, 12.0f, 12.0f}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-3}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 3, 2, 2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.8f, 0.8f, 0.6f, 0.0f, 0.6f, 0.0f, 0.8f, 0.8f, 0.0f, 0.6f, 0.36f, 0.48f, 0.8f, 0.64f, 0.48f, 0.6f, 0.36f, 0.6f, 0.8f, 0.64f, 0.48f, 0.48f}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = true, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::UNKNOWN }; return model; } const auto dummy_test_model_dim4_axis1_neg_relaxed = TestModelManager::get().add("l2_normalization_axis_dim4_axis1_neg_relaxed", get_test_model_dim4_axis1_neg_relaxed()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim4_axis1_neg_relaxed_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 3, 2, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-3}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 3, 2, 2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.8f, 0.8f, 0.6f, 0.0f, 0.6f, 0.0f, 0.8f, 0.8f, 0.0f, 0.6f, 0.36f, 0.48f, 0.8f, 0.64f, 0.48f, 0.6f, 0.36f, 0.6f, 0.8f, 0.64f, 0.48f, 0.48f}) }, { // op1_new .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 3, 2, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 8.0f, 12.0f, 3.0f, 0.0f, 6.0f, 0.0f, 4.0f, 4.0f, 0.0f, 9.0f, 9.0f, 12.0f, 20.0f, 16.0f, 12.0f, 15.0f, 9.0f, 15.0f, 20.0f, 16.0f, 12.0f, 12.0f}) }, { // placeholder13 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f}) }, { // param13 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = true, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::UNKNOWN }; return model; } const auto dummy_test_model_dim4_axis1_neg_relaxed_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim4_axis1_neg_relaxed_all_inputs_as_internal", get_test_model_dim4_axis1_neg_relaxed_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim4_axis1_neg_float16() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {2, 3, 2, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 3.0f, 8.0f, 12.0f, 3.0f, 0.0f, 6.0f, 0.0f, 4.0f, 4.0f, 0.0f, 9.0f, 9.0f, 12.0f, 20.0f, 16.0f, 12.0f, 15.0f, 9.0f, 15.0f, 20.0f, 16.0f, 12.0f, 12.0f}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-3}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {2, 3, 2, 2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 0.6000000238418579f, 0.800000011920929f, 0.800000011920929f, 0.6000000238418579f, 0.0f, 0.6000000238418579f, 0.0f, 0.800000011920929f, 0.800000011920929f, 0.0f, 0.6000000238418579f, 0.36000001430511475f, 0.47999998927116394f, 0.800000011920929f, 0.6399999856948853f, 0.47999998927116394f, 0.6000000238418579f, 0.36000001430511475f, 0.6000000238418579f, 0.800000011920929f, 0.6399999856948853f, 0.47999998927116394f, 0.47999998927116394f}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim4_axis1_neg_float16 = TestModelManager::get().add("l2_normalization_axis_dim4_axis1_neg_float16", get_test_model_dim4_axis1_neg_float16()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim4_axis1_neg_float16_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {2, 3, 2, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-3}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {2, 3, 2, 2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 0.6000000238418579f, 0.800000011920929f, 0.800000011920929f, 0.6000000238418579f, 0.0f, 0.6000000238418579f, 0.0f, 0.800000011920929f, 0.800000011920929f, 0.0f, 0.6000000238418579f, 0.36000001430511475f, 0.47999998927116394f, 0.800000011920929f, 0.6399999856948853f, 0.47999998927116394f, 0.6000000238418579f, 0.36000001430511475f, 0.6000000238418579f, 0.800000011920929f, 0.6399999856948853f, 0.47999998927116394f, 0.47999998927116394f}) }, { // op1_new .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {2, 3, 2, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 3.0f, 8.0f, 12.0f, 3.0f, 0.0f, 6.0f, 0.0f, 4.0f, 4.0f, 0.0f, 9.0f, 9.0f, 12.0f, 20.0f, 16.0f, 12.0f, 15.0f, 9.0f, 15.0f, 20.0f, 16.0f, 12.0f, 12.0f}) }, { // placeholder14 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f}) }, { // param14 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim4_axis1_neg_float16_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim4_axis1_neg_float16_all_inputs_as_internal", get_test_model_dim4_axis1_neg_float16_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim4_axis1_neg_quant8() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {2, 3, 2, 2}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({32, 62, 112, 152, 62, 32, 92, 32, 72, 72, 32, 122, 122, 152, 232, 192, 152, 182, 122, 182, 232, 192, 152, 152}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-3}) }, { // op2 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {2, 3, 2, 2}, .numberOfConsumers = 0, .scale = 0.0078125f, .zeroPoint = 128, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({128, 205, 230, 230, 205, 128, 205, 128, 230, 230, 128, 205, 174, 189, 230, 210, 189, 205, 174, 205, 230, 210, 189, 189}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim4_axis1_neg_quant8 = TestModelManager::get().add("l2_normalization_axis_dim4_axis1_neg_quant8", get_test_model_dim4_axis1_neg_quant8()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim4_axis1_neg_quant8_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {2, 3, 2, 2}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-3}) }, { // op2 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {2, 3, 2, 2}, .numberOfConsumers = 0, .scale = 0.0078125f, .zeroPoint = 128, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({128, 205, 230, 230, 205, 128, 205, 128, 230, 230, 128, 205, 174, 189, 230, 210, 189, 205, 174, 205, 230, 210, 189, 189}) }, { // op1_new .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {2, 3, 2, 2}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({32, 62, 112, 152, 62, 32, 92, 32, 72, 72, 32, 122, 122, 152, 232, 192, 152, 182, 122, 182, 232, 192, 152, 152}) }, { // placeholder15 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({32}) }, { // param15 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim4_axis1_neg_quant8_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim4_axis1_neg_quant8_all_inputs_as_internal", get_test_model_dim4_axis1_neg_quant8_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim4_axis2() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 2, 3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 3.0f, 0.0f, 4.0f, 4.0f, 8.0f, 12.0f, 6.0f, 0.0f, 0.0f, 9.0f, 9.0f, 12.0f, 12.0f, 15.0f, 20.0f, 16.0f, 20.0f, 16.0f, 9.0f, 15.0f, 12.0f, 12.0f}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({2}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 2, 3, 2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.6f, 0.0f, 0.8f, 0.8f, 0.8f, 0.8f, 0.6f, 0.0f, 0.0f, 0.6f, 0.36f, 0.48f, 0.48f, 0.6f, 0.8f, 0.64f, 0.8f, 0.64f, 0.36f, 0.6f, 0.48f, 0.48f}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim4_axis2 = TestModelManager::get().add("l2_normalization_axis_dim4_axis2", get_test_model_dim4_axis2()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim4_axis2_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 2, 3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({2}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 2, 3, 2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.6f, 0.0f, 0.8f, 0.8f, 0.8f, 0.8f, 0.6f, 0.0f, 0.0f, 0.6f, 0.36f, 0.48f, 0.48f, 0.6f, 0.8f, 0.64f, 0.8f, 0.64f, 0.36f, 0.6f, 0.48f, 0.48f}) }, { // op1_new .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 2, 3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 3.0f, 0.0f, 4.0f, 4.0f, 8.0f, 12.0f, 6.0f, 0.0f, 0.0f, 9.0f, 9.0f, 12.0f, 12.0f, 15.0f, 20.0f, 16.0f, 20.0f, 16.0f, 9.0f, 15.0f, 12.0f, 12.0f}) }, { // placeholder16 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f}) }, { // param16 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim4_axis2_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim4_axis2_all_inputs_as_internal", get_test_model_dim4_axis2_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim4_axis2_relaxed() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 2, 3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 3.0f, 0.0f, 4.0f, 4.0f, 8.0f, 12.0f, 6.0f, 0.0f, 0.0f, 9.0f, 9.0f, 12.0f, 12.0f, 15.0f, 20.0f, 16.0f, 20.0f, 16.0f, 9.0f, 15.0f, 12.0f, 12.0f}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({2}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 2, 3, 2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.6f, 0.0f, 0.8f, 0.8f, 0.8f, 0.8f, 0.6f, 0.0f, 0.0f, 0.6f, 0.36f, 0.48f, 0.48f, 0.6f, 0.8f, 0.64f, 0.8f, 0.64f, 0.36f, 0.6f, 0.48f, 0.48f}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = true, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::UNKNOWN }; return model; } const auto dummy_test_model_dim4_axis2_relaxed = TestModelManager::get().add("l2_normalization_axis_dim4_axis2_relaxed", get_test_model_dim4_axis2_relaxed()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim4_axis2_relaxed_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 2, 3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({2}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 2, 3, 2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.6f, 0.0f, 0.8f, 0.8f, 0.8f, 0.8f, 0.6f, 0.0f, 0.0f, 0.6f, 0.36f, 0.48f, 0.48f, 0.6f, 0.8f, 0.64f, 0.8f, 0.64f, 0.36f, 0.6f, 0.48f, 0.48f}) }, { // op1_new .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 2, 3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 3.0f, 0.0f, 4.0f, 4.0f, 8.0f, 12.0f, 6.0f, 0.0f, 0.0f, 9.0f, 9.0f, 12.0f, 12.0f, 15.0f, 20.0f, 16.0f, 20.0f, 16.0f, 9.0f, 15.0f, 12.0f, 12.0f}) }, { // placeholder17 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f}) }, { // param17 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = true, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::UNKNOWN }; return model; } const auto dummy_test_model_dim4_axis2_relaxed_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim4_axis2_relaxed_all_inputs_as_internal", get_test_model_dim4_axis2_relaxed_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim4_axis2_float16() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {2, 2, 3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 3.0f, 3.0f, 0.0f, 4.0f, 4.0f, 8.0f, 12.0f, 6.0f, 0.0f, 0.0f, 9.0f, 9.0f, 12.0f, 12.0f, 15.0f, 20.0f, 16.0f, 20.0f, 16.0f, 9.0f, 15.0f, 12.0f, 12.0f}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({2}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {2, 2, 3, 2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 0.6000000238418579f, 0.6000000238418579f, 0.0f, 0.800000011920929f, 0.800000011920929f, 0.800000011920929f, 0.800000011920929f, 0.6000000238418579f, 0.0f, 0.0f, 0.6000000238418579f, 0.36000001430511475f, 0.47999998927116394f, 0.47999998927116394f, 0.6000000238418579f, 0.800000011920929f, 0.6399999856948853f, 0.800000011920929f, 0.6399999856948853f, 0.36000001430511475f, 0.6000000238418579f, 0.47999998927116394f, 0.47999998927116394f}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim4_axis2_float16 = TestModelManager::get().add("l2_normalization_axis_dim4_axis2_float16", get_test_model_dim4_axis2_float16()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim4_axis2_float16_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {2, 2, 3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({2}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {2, 2, 3, 2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 0.6000000238418579f, 0.6000000238418579f, 0.0f, 0.800000011920929f, 0.800000011920929f, 0.800000011920929f, 0.800000011920929f, 0.6000000238418579f, 0.0f, 0.0f, 0.6000000238418579f, 0.36000001430511475f, 0.47999998927116394f, 0.47999998927116394f, 0.6000000238418579f, 0.800000011920929f, 0.6399999856948853f, 0.800000011920929f, 0.6399999856948853f, 0.36000001430511475f, 0.6000000238418579f, 0.47999998927116394f, 0.47999998927116394f}) }, { // op1_new .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {2, 2, 3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 3.0f, 3.0f, 0.0f, 4.0f, 4.0f, 8.0f, 12.0f, 6.0f, 0.0f, 0.0f, 9.0f, 9.0f, 12.0f, 12.0f, 15.0f, 20.0f, 16.0f, 20.0f, 16.0f, 9.0f, 15.0f, 12.0f, 12.0f}) }, { // placeholder18 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f}) }, { // param18 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim4_axis2_float16_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim4_axis2_float16_all_inputs_as_internal", get_test_model_dim4_axis2_float16_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim4_axis2_quant8() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {2, 2, 3, 2}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({32, 62, 62, 32, 72, 72, 112, 152, 92, 32, 32, 122, 122, 152, 152, 182, 232, 192, 232, 192, 122, 182, 152, 152}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({2}) }, { // op2 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {2, 2, 3, 2}, .numberOfConsumers = 0, .scale = 0.0078125f, .zeroPoint = 128, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({128, 205, 205, 128, 230, 230, 230, 230, 205, 128, 128, 205, 174, 189, 189, 205, 230, 210, 230, 210, 174, 205, 189, 189}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim4_axis2_quant8 = TestModelManager::get().add("l2_normalization_axis_dim4_axis2_quant8", get_test_model_dim4_axis2_quant8()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim4_axis2_quant8_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {2, 2, 3, 2}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({2}) }, { // op2 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {2, 2, 3, 2}, .numberOfConsumers = 0, .scale = 0.0078125f, .zeroPoint = 128, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({128, 205, 205, 128, 230, 230, 230, 230, 205, 128, 128, 205, 174, 189, 189, 205, 230, 210, 230, 210, 174, 205, 189, 189}) }, { // op1_new .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {2, 2, 3, 2}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({32, 62, 62, 32, 72, 72, 112, 152, 92, 32, 32, 122, 122, 152, 152, 182, 232, 192, 232, 192, 122, 182, 152, 152}) }, { // placeholder19 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({32}) }, { // param19 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim4_axis2_quant8_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim4_axis2_quant8_all_inputs_as_internal", get_test_model_dim4_axis2_quant8_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim4_axis2_neg() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 2, 3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 3.0f, 0.0f, 4.0f, 4.0f, 8.0f, 12.0f, 6.0f, 0.0f, 0.0f, 9.0f, 9.0f, 12.0f, 12.0f, 15.0f, 20.0f, 16.0f, 20.0f, 16.0f, 9.0f, 15.0f, 12.0f, 12.0f}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-2}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 2, 3, 2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.6f, 0.0f, 0.8f, 0.8f, 0.8f, 0.8f, 0.6f, 0.0f, 0.0f, 0.6f, 0.36f, 0.48f, 0.48f, 0.6f, 0.8f, 0.64f, 0.8f, 0.64f, 0.36f, 0.6f, 0.48f, 0.48f}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim4_axis2_neg = TestModelManager::get().add("l2_normalization_axis_dim4_axis2_neg", get_test_model_dim4_axis2_neg()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim4_axis2_neg_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 2, 3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-2}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 2, 3, 2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.6f, 0.0f, 0.8f, 0.8f, 0.8f, 0.8f, 0.6f, 0.0f, 0.0f, 0.6f, 0.36f, 0.48f, 0.48f, 0.6f, 0.8f, 0.64f, 0.8f, 0.64f, 0.36f, 0.6f, 0.48f, 0.48f}) }, { // op1_new .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 2, 3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 3.0f, 0.0f, 4.0f, 4.0f, 8.0f, 12.0f, 6.0f, 0.0f, 0.0f, 9.0f, 9.0f, 12.0f, 12.0f, 15.0f, 20.0f, 16.0f, 20.0f, 16.0f, 9.0f, 15.0f, 12.0f, 12.0f}) }, { // placeholder20 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f}) }, { // param20 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim4_axis2_neg_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim4_axis2_neg_all_inputs_as_internal", get_test_model_dim4_axis2_neg_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim4_axis2_neg_relaxed() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 2, 3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 3.0f, 0.0f, 4.0f, 4.0f, 8.0f, 12.0f, 6.0f, 0.0f, 0.0f, 9.0f, 9.0f, 12.0f, 12.0f, 15.0f, 20.0f, 16.0f, 20.0f, 16.0f, 9.0f, 15.0f, 12.0f, 12.0f}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-2}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 2, 3, 2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.6f, 0.0f, 0.8f, 0.8f, 0.8f, 0.8f, 0.6f, 0.0f, 0.0f, 0.6f, 0.36f, 0.48f, 0.48f, 0.6f, 0.8f, 0.64f, 0.8f, 0.64f, 0.36f, 0.6f, 0.48f, 0.48f}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = true, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::UNKNOWN }; return model; } const auto dummy_test_model_dim4_axis2_neg_relaxed = TestModelManager::get().add("l2_normalization_axis_dim4_axis2_neg_relaxed", get_test_model_dim4_axis2_neg_relaxed()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim4_axis2_neg_relaxed_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 2, 3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-2}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 2, 3, 2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.6f, 0.0f, 0.8f, 0.8f, 0.8f, 0.8f, 0.6f, 0.0f, 0.0f, 0.6f, 0.36f, 0.48f, 0.48f, 0.6f, 0.8f, 0.64f, 0.8f, 0.64f, 0.36f, 0.6f, 0.48f, 0.48f}) }, { // op1_new .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 2, 3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 3.0f, 0.0f, 4.0f, 4.0f, 8.0f, 12.0f, 6.0f, 0.0f, 0.0f, 9.0f, 9.0f, 12.0f, 12.0f, 15.0f, 20.0f, 16.0f, 20.0f, 16.0f, 9.0f, 15.0f, 12.0f, 12.0f}) }, { // placeholder21 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f}) }, { // param21 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = true, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::UNKNOWN }; return model; } const auto dummy_test_model_dim4_axis2_neg_relaxed_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim4_axis2_neg_relaxed_all_inputs_as_internal", get_test_model_dim4_axis2_neg_relaxed_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim4_axis2_neg_float16() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {2, 2, 3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 3.0f, 3.0f, 0.0f, 4.0f, 4.0f, 8.0f, 12.0f, 6.0f, 0.0f, 0.0f, 9.0f, 9.0f, 12.0f, 12.0f, 15.0f, 20.0f, 16.0f, 20.0f, 16.0f, 9.0f, 15.0f, 12.0f, 12.0f}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-2}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {2, 2, 3, 2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 0.6000000238418579f, 0.6000000238418579f, 0.0f, 0.800000011920929f, 0.800000011920929f, 0.800000011920929f, 0.800000011920929f, 0.6000000238418579f, 0.0f, 0.0f, 0.6000000238418579f, 0.36000001430511475f, 0.47999998927116394f, 0.47999998927116394f, 0.6000000238418579f, 0.800000011920929f, 0.6399999856948853f, 0.800000011920929f, 0.6399999856948853f, 0.36000001430511475f, 0.6000000238418579f, 0.47999998927116394f, 0.47999998927116394f}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim4_axis2_neg_float16 = TestModelManager::get().add("l2_normalization_axis_dim4_axis2_neg_float16", get_test_model_dim4_axis2_neg_float16()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim4_axis2_neg_float16_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {2, 2, 3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-2}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {2, 2, 3, 2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 0.6000000238418579f, 0.6000000238418579f, 0.0f, 0.800000011920929f, 0.800000011920929f, 0.800000011920929f, 0.800000011920929f, 0.6000000238418579f, 0.0f, 0.0f, 0.6000000238418579f, 0.36000001430511475f, 0.47999998927116394f, 0.47999998927116394f, 0.6000000238418579f, 0.800000011920929f, 0.6399999856948853f, 0.800000011920929f, 0.6399999856948853f, 0.36000001430511475f, 0.6000000238418579f, 0.47999998927116394f, 0.47999998927116394f}) }, { // op1_new .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {2, 2, 3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 3.0f, 3.0f, 0.0f, 4.0f, 4.0f, 8.0f, 12.0f, 6.0f, 0.0f, 0.0f, 9.0f, 9.0f, 12.0f, 12.0f, 15.0f, 20.0f, 16.0f, 20.0f, 16.0f, 9.0f, 15.0f, 12.0f, 12.0f}) }, { // placeholder22 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f}) }, { // param22 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim4_axis2_neg_float16_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim4_axis2_neg_float16_all_inputs_as_internal", get_test_model_dim4_axis2_neg_float16_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim4_axis2_neg_quant8() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {2, 2, 3, 2}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({32, 62, 62, 32, 72, 72, 112, 152, 92, 32, 32, 122, 122, 152, 152, 182, 232, 192, 232, 192, 122, 182, 152, 152}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-2}) }, { // op2 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {2, 2, 3, 2}, .numberOfConsumers = 0, .scale = 0.0078125f, .zeroPoint = 128, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({128, 205, 205, 128, 230, 230, 230, 230, 205, 128, 128, 205, 174, 189, 189, 205, 230, 210, 230, 210, 174, 205, 189, 189}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim4_axis2_neg_quant8 = TestModelManager::get().add("l2_normalization_axis_dim4_axis2_neg_quant8", get_test_model_dim4_axis2_neg_quant8()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim4_axis2_neg_quant8_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {2, 2, 3, 2}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-2}) }, { // op2 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {2, 2, 3, 2}, .numberOfConsumers = 0, .scale = 0.0078125f, .zeroPoint = 128, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({128, 205, 205, 128, 230, 230, 230, 230, 205, 128, 128, 205, 174, 189, 189, 205, 230, 210, 230, 210, 174, 205, 189, 189}) }, { // op1_new .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {2, 2, 3, 2}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({32, 62, 62, 32, 72, 72, 112, 152, 92, 32, 32, 122, 122, 152, 152, 182, 232, 192, 232, 192, 122, 182, 152, 152}) }, { // placeholder23 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({32}) }, { // param23 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim4_axis2_neg_quant8_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim4_axis2_neg_quant8_all_inputs_as_internal", get_test_model_dim4_axis2_neg_quant8_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim4_axis3() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 2, 2, 3}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 4.0f, 3.0f, 0.0f, 4.0f, 8.0f, 6.0f, 0.0f, 12.0f, 0.0f, 9.0f, 9.0f, 12.0f, 20.0f, 12.0f, 15.0f, 16.0f, 20.0f, 9.0f, 12.0f, 16.0f, 15.0f, 12.0f}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({3}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 2, 2, 3}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.8f, 0.6f, 0.0f, 0.8f, 0.8f, 0.6f, 0.0f, 0.8f, 0.0f, 0.6f, 0.36f, 0.48f, 0.8f, 0.48f, 0.6f, 0.64f, 0.8f, 0.36f, 0.48f, 0.64f, 0.6f, 0.48f}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim4_axis3 = TestModelManager::get().add("l2_normalization_axis_dim4_axis3", get_test_model_dim4_axis3()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim4_axis3_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 2, 2, 3}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({3}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 2, 2, 3}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.8f, 0.6f, 0.0f, 0.8f, 0.8f, 0.6f, 0.0f, 0.8f, 0.0f, 0.6f, 0.36f, 0.48f, 0.8f, 0.48f, 0.6f, 0.64f, 0.8f, 0.36f, 0.48f, 0.64f, 0.6f, 0.48f}) }, { // op1_new .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 2, 2, 3}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 4.0f, 3.0f, 0.0f, 4.0f, 8.0f, 6.0f, 0.0f, 12.0f, 0.0f, 9.0f, 9.0f, 12.0f, 20.0f, 12.0f, 15.0f, 16.0f, 20.0f, 9.0f, 12.0f, 16.0f, 15.0f, 12.0f}) }, { // placeholder24 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f}) }, { // param24 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim4_axis3_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim4_axis3_all_inputs_as_internal", get_test_model_dim4_axis3_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim4_axis3_relaxed() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 2, 2, 3}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 4.0f, 3.0f, 0.0f, 4.0f, 8.0f, 6.0f, 0.0f, 12.0f, 0.0f, 9.0f, 9.0f, 12.0f, 20.0f, 12.0f, 15.0f, 16.0f, 20.0f, 9.0f, 12.0f, 16.0f, 15.0f, 12.0f}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({3}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 2, 2, 3}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.8f, 0.6f, 0.0f, 0.8f, 0.8f, 0.6f, 0.0f, 0.8f, 0.0f, 0.6f, 0.36f, 0.48f, 0.8f, 0.48f, 0.6f, 0.64f, 0.8f, 0.36f, 0.48f, 0.64f, 0.6f, 0.48f}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = true, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::UNKNOWN }; return model; } const auto dummy_test_model_dim4_axis3_relaxed = TestModelManager::get().add("l2_normalization_axis_dim4_axis3_relaxed", get_test_model_dim4_axis3_relaxed()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim4_axis3_relaxed_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 2, 2, 3}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({3}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 2, 2, 3}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.8f, 0.6f, 0.0f, 0.8f, 0.8f, 0.6f, 0.0f, 0.8f, 0.0f, 0.6f, 0.36f, 0.48f, 0.8f, 0.48f, 0.6f, 0.64f, 0.8f, 0.36f, 0.48f, 0.64f, 0.6f, 0.48f}) }, { // op1_new .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 2, 2, 3}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 4.0f, 3.0f, 0.0f, 4.0f, 8.0f, 6.0f, 0.0f, 12.0f, 0.0f, 9.0f, 9.0f, 12.0f, 20.0f, 12.0f, 15.0f, 16.0f, 20.0f, 9.0f, 12.0f, 16.0f, 15.0f, 12.0f}) }, { // placeholder25 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f}) }, { // param25 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = true, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::UNKNOWN }; return model; } const auto dummy_test_model_dim4_axis3_relaxed_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim4_axis3_relaxed_all_inputs_as_internal", get_test_model_dim4_axis3_relaxed_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim4_axis3_float16() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {2, 2, 2, 3}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 3.0f, 4.0f, 3.0f, 0.0f, 4.0f, 8.0f, 6.0f, 0.0f, 12.0f, 0.0f, 9.0f, 9.0f, 12.0f, 20.0f, 12.0f, 15.0f, 16.0f, 20.0f, 9.0f, 12.0f, 16.0f, 15.0f, 12.0f}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({3}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {2, 2, 2, 3}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 0.6000000238418579f, 0.800000011920929f, 0.6000000238418579f, 0.0f, 0.800000011920929f, 0.800000011920929f, 0.6000000238418579f, 0.0f, 0.800000011920929f, 0.0f, 0.6000000238418579f, 0.36000001430511475f, 0.47999998927116394f, 0.800000011920929f, 0.47999998927116394f, 0.6000000238418579f, 0.6399999856948853f, 0.800000011920929f, 0.36000001430511475f, 0.47999998927116394f, 0.6399999856948853f, 0.6000000238418579f, 0.47999998927116394f}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim4_axis3_float16 = TestModelManager::get().add("l2_normalization_axis_dim4_axis3_float16", get_test_model_dim4_axis3_float16()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim4_axis3_float16_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {2, 2, 2, 3}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({3}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {2, 2, 2, 3}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 0.6000000238418579f, 0.800000011920929f, 0.6000000238418579f, 0.0f, 0.800000011920929f, 0.800000011920929f, 0.6000000238418579f, 0.0f, 0.800000011920929f, 0.0f, 0.6000000238418579f, 0.36000001430511475f, 0.47999998927116394f, 0.800000011920929f, 0.47999998927116394f, 0.6000000238418579f, 0.6399999856948853f, 0.800000011920929f, 0.36000001430511475f, 0.47999998927116394f, 0.6399999856948853f, 0.6000000238418579f, 0.47999998927116394f}) }, { // op1_new .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {2, 2, 2, 3}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 3.0f, 4.0f, 3.0f, 0.0f, 4.0f, 8.0f, 6.0f, 0.0f, 12.0f, 0.0f, 9.0f, 9.0f, 12.0f, 20.0f, 12.0f, 15.0f, 16.0f, 20.0f, 9.0f, 12.0f, 16.0f, 15.0f, 12.0f}) }, { // placeholder26 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f}) }, { // param26 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim4_axis3_float16_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim4_axis3_float16_all_inputs_as_internal", get_test_model_dim4_axis3_float16_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim4_axis3_quant8() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {2, 2, 2, 3}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({32, 62, 72, 62, 32, 72, 112, 92, 32, 152, 32, 122, 122, 152, 232, 152, 182, 192, 232, 122, 152, 192, 182, 152}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({3}) }, { // op2 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {2, 2, 2, 3}, .numberOfConsumers = 0, .scale = 0.0078125f, .zeroPoint = 128, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({128, 205, 230, 205, 128, 230, 230, 205, 128, 230, 128, 205, 174, 189, 230, 189, 205, 210, 230, 174, 189, 210, 205, 189}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim4_axis3_quant8 = TestModelManager::get().add("l2_normalization_axis_dim4_axis3_quant8", get_test_model_dim4_axis3_quant8()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim4_axis3_quant8_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {2, 2, 2, 3}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({3}) }, { // op2 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {2, 2, 2, 3}, .numberOfConsumers = 0, .scale = 0.0078125f, .zeroPoint = 128, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({128, 205, 230, 205, 128, 230, 230, 205, 128, 230, 128, 205, 174, 189, 230, 189, 205, 210, 230, 174, 189, 210, 205, 189}) }, { // op1_new .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {2, 2, 2, 3}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({32, 62, 72, 62, 32, 72, 112, 92, 32, 152, 32, 122, 122, 152, 232, 152, 182, 192, 232, 122, 152, 192, 182, 152}) }, { // placeholder27 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({32}) }, { // param27 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim4_axis3_quant8_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim4_axis3_quant8_all_inputs_as_internal", get_test_model_dim4_axis3_quant8_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim4_axis3_neg() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 2, 2, 3}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 4.0f, 3.0f, 0.0f, 4.0f, 8.0f, 6.0f, 0.0f, 12.0f, 0.0f, 9.0f, 9.0f, 12.0f, 20.0f, 12.0f, 15.0f, 16.0f, 20.0f, 9.0f, 12.0f, 16.0f, 15.0f, 12.0f}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-1}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 2, 2, 3}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.8f, 0.6f, 0.0f, 0.8f, 0.8f, 0.6f, 0.0f, 0.8f, 0.0f, 0.6f, 0.36f, 0.48f, 0.8f, 0.48f, 0.6f, 0.64f, 0.8f, 0.36f, 0.48f, 0.64f, 0.6f, 0.48f}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_0 }; return model; } const auto dummy_test_model_dim4_axis3_neg = TestModelManager::get().add("l2_normalization_axis_dim4_axis3_neg", get_test_model_dim4_axis3_neg()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim4_axis3_neg_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 2, 2, 3}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-1}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 2, 2, 3}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.8f, 0.6f, 0.0f, 0.8f, 0.8f, 0.6f, 0.0f, 0.8f, 0.0f, 0.6f, 0.36f, 0.48f, 0.8f, 0.48f, 0.6f, 0.64f, 0.8f, 0.36f, 0.48f, 0.64f, 0.6f, 0.48f}) }, { // op1_new .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 2, 2, 3}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 4.0f, 3.0f, 0.0f, 4.0f, 8.0f, 6.0f, 0.0f, 12.0f, 0.0f, 9.0f, 9.0f, 12.0f, 20.0f, 12.0f, 15.0f, 16.0f, 20.0f, 9.0f, 12.0f, 16.0f, 15.0f, 12.0f}) }, { // placeholder28 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f}) }, { // param28 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_0 }; return model; } const auto dummy_test_model_dim4_axis3_neg_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim4_axis3_neg_all_inputs_as_internal", get_test_model_dim4_axis3_neg_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim4_axis3_neg_relaxed() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 2, 2, 3}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 4.0f, 3.0f, 0.0f, 4.0f, 8.0f, 6.0f, 0.0f, 12.0f, 0.0f, 9.0f, 9.0f, 12.0f, 20.0f, 12.0f, 15.0f, 16.0f, 20.0f, 9.0f, 12.0f, 16.0f, 15.0f, 12.0f}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-1}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 2, 2, 3}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.8f, 0.6f, 0.0f, 0.8f, 0.8f, 0.6f, 0.0f, 0.8f, 0.0f, 0.6f, 0.36f, 0.48f, 0.8f, 0.48f, 0.6f, 0.64f, 0.8f, 0.36f, 0.48f, 0.64f, 0.6f, 0.48f}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = true, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::UNKNOWN }; return model; } const auto dummy_test_model_dim4_axis3_neg_relaxed = TestModelManager::get().add("l2_normalization_axis_dim4_axis3_neg_relaxed", get_test_model_dim4_axis3_neg_relaxed()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim4_axis3_neg_relaxed_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 2, 2, 3}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-1}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 2, 2, 3}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.8f, 0.6f, 0.0f, 0.8f, 0.8f, 0.6f, 0.0f, 0.8f, 0.0f, 0.6f, 0.36f, 0.48f, 0.8f, 0.48f, 0.6f, 0.64f, 0.8f, 0.36f, 0.48f, 0.64f, 0.6f, 0.48f}) }, { // op1_new .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 2, 2, 3}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 4.0f, 3.0f, 0.0f, 4.0f, 8.0f, 6.0f, 0.0f, 12.0f, 0.0f, 9.0f, 9.0f, 12.0f, 20.0f, 12.0f, 15.0f, 16.0f, 20.0f, 9.0f, 12.0f, 16.0f, 15.0f, 12.0f}) }, { // placeholder29 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f}) }, { // param29 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = true, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::UNKNOWN }; return model; } const auto dummy_test_model_dim4_axis3_neg_relaxed_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim4_axis3_neg_relaxed_all_inputs_as_internal", get_test_model_dim4_axis3_neg_relaxed_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim4_axis3_neg_float16() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {2, 2, 2, 3}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 3.0f, 4.0f, 3.0f, 0.0f, 4.0f, 8.0f, 6.0f, 0.0f, 12.0f, 0.0f, 9.0f, 9.0f, 12.0f, 20.0f, 12.0f, 15.0f, 16.0f, 20.0f, 9.0f, 12.0f, 16.0f, 15.0f, 12.0f}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-1}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {2, 2, 2, 3}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 0.6000000238418579f, 0.800000011920929f, 0.6000000238418579f, 0.0f, 0.800000011920929f, 0.800000011920929f, 0.6000000238418579f, 0.0f, 0.800000011920929f, 0.0f, 0.6000000238418579f, 0.36000001430511475f, 0.47999998927116394f, 0.800000011920929f, 0.47999998927116394f, 0.6000000238418579f, 0.6399999856948853f, 0.800000011920929f, 0.36000001430511475f, 0.47999998927116394f, 0.6399999856948853f, 0.6000000238418579f, 0.47999998927116394f}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim4_axis3_neg_float16 = TestModelManager::get().add("l2_normalization_axis_dim4_axis3_neg_float16", get_test_model_dim4_axis3_neg_float16()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim4_axis3_neg_float16_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {2, 2, 2, 3}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-1}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {2, 2, 2, 3}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 0.6000000238418579f, 0.800000011920929f, 0.6000000238418579f, 0.0f, 0.800000011920929f, 0.800000011920929f, 0.6000000238418579f, 0.0f, 0.800000011920929f, 0.0f, 0.6000000238418579f, 0.36000001430511475f, 0.47999998927116394f, 0.800000011920929f, 0.47999998927116394f, 0.6000000238418579f, 0.6399999856948853f, 0.800000011920929f, 0.36000001430511475f, 0.47999998927116394f, 0.6399999856948853f, 0.6000000238418579f, 0.47999998927116394f}) }, { // op1_new .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {2, 2, 2, 3}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 3.0f, 4.0f, 3.0f, 0.0f, 4.0f, 8.0f, 6.0f, 0.0f, 12.0f, 0.0f, 9.0f, 9.0f, 12.0f, 20.0f, 12.0f, 15.0f, 16.0f, 20.0f, 9.0f, 12.0f, 16.0f, 15.0f, 12.0f}) }, { // placeholder30 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f}) }, { // param30 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim4_axis3_neg_float16_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim4_axis3_neg_float16_all_inputs_as_internal", get_test_model_dim4_axis3_neg_float16_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim4_axis3_neg_quant8() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {2, 2, 2, 3}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({32, 62, 72, 62, 32, 72, 112, 92, 32, 152, 32, 122, 122, 152, 232, 152, 182, 192, 232, 122, 152, 192, 182, 152}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-1}) }, { // op2 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {2, 2, 2, 3}, .numberOfConsumers = 0, .scale = 0.0078125f, .zeroPoint = 128, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({128, 205, 230, 205, 128, 230, 230, 205, 128, 230, 128, 205, 174, 189, 230, 189, 205, 210, 230, 174, 189, 210, 205, 189}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim4_axis3_neg_quant8 = TestModelManager::get().add("l2_normalization_axis_dim4_axis3_neg_quant8", get_test_model_dim4_axis3_neg_quant8()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim4_axis3_neg_quant8_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {2, 2, 2, 3}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-1}) }, { // op2 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {2, 2, 2, 3}, .numberOfConsumers = 0, .scale = 0.0078125f, .zeroPoint = 128, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({128, 205, 230, 205, 128, 230, 230, 205, 128, 230, 128, 205, 174, 189, 230, 189, 205, 210, 230, 174, 189, 210, 205, 189}) }, { // op1_new .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {2, 2, 2, 3}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({32, 62, 72, 62, 32, 72, 112, 92, 32, 152, 32, 122, 122, 152, 232, 152, 182, 192, 232, 122, 152, 192, 182, 152}) }, { // placeholder31 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({32}) }, { // param31 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim4_axis3_neg_quant8_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim4_axis3_neg_quant8_all_inputs_as_internal", get_test_model_dim4_axis3_neg_quant8_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim3_axis0() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3, 2, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 8.0f, 12.0f, 3.0f, 0.0f, 6.0f, 0.0f, 4.0f, 4.0f, 0.0f, 9.0f}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3, 2, 2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.8f, 0.8f, 0.6f, 0.0f, 0.6f, 0.0f, 0.8f, 0.8f, 0.0f, 0.6f}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim3_axis0 = TestModelManager::get().add("l2_normalization_axis_dim3_axis0", get_test_model_dim3_axis0()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim3_axis0_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3, 2, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3, 2, 2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.8f, 0.8f, 0.6f, 0.0f, 0.6f, 0.0f, 0.8f, 0.8f, 0.0f, 0.6f}) }, { // op1_new .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3, 2, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 8.0f, 12.0f, 3.0f, 0.0f, 6.0f, 0.0f, 4.0f, 4.0f, 0.0f, 9.0f}) }, { // placeholder32 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f}) }, { // param32 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim3_axis0_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim3_axis0_all_inputs_as_internal", get_test_model_dim3_axis0_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim3_axis0_relaxed() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3, 2, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 8.0f, 12.0f, 3.0f, 0.0f, 6.0f, 0.0f, 4.0f, 4.0f, 0.0f, 9.0f}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3, 2, 2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.8f, 0.8f, 0.6f, 0.0f, 0.6f, 0.0f, 0.8f, 0.8f, 0.0f, 0.6f}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = true, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::UNKNOWN }; return model; } const auto dummy_test_model_dim3_axis0_relaxed = TestModelManager::get().add("l2_normalization_axis_dim3_axis0_relaxed", get_test_model_dim3_axis0_relaxed()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim3_axis0_relaxed_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3, 2, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3, 2, 2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.8f, 0.8f, 0.6f, 0.0f, 0.6f, 0.0f, 0.8f, 0.8f, 0.0f, 0.6f}) }, { // op1_new .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3, 2, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 8.0f, 12.0f, 3.0f, 0.0f, 6.0f, 0.0f, 4.0f, 4.0f, 0.0f, 9.0f}) }, { // placeholder33 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f}) }, { // param33 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = true, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::UNKNOWN }; return model; } const auto dummy_test_model_dim3_axis0_relaxed_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim3_axis0_relaxed_all_inputs_as_internal", get_test_model_dim3_axis0_relaxed_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim3_axis0_float16() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {3, 2, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 3.0f, 8.0f, 12.0f, 3.0f, 0.0f, 6.0f, 0.0f, 4.0f, 4.0f, 0.0f, 9.0f}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {3, 2, 2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 0.6000000238418579f, 0.800000011920929f, 0.800000011920929f, 0.6000000238418579f, 0.0f, 0.6000000238418579f, 0.0f, 0.800000011920929f, 0.800000011920929f, 0.0f, 0.6000000238418579f}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim3_axis0_float16 = TestModelManager::get().add("l2_normalization_axis_dim3_axis0_float16", get_test_model_dim3_axis0_float16()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim3_axis0_float16_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {3, 2, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {3, 2, 2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 0.6000000238418579f, 0.800000011920929f, 0.800000011920929f, 0.6000000238418579f, 0.0f, 0.6000000238418579f, 0.0f, 0.800000011920929f, 0.800000011920929f, 0.0f, 0.6000000238418579f}) }, { // op1_new .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {3, 2, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 3.0f, 8.0f, 12.0f, 3.0f, 0.0f, 6.0f, 0.0f, 4.0f, 4.0f, 0.0f, 9.0f}) }, { // placeholder34 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f}) }, { // param34 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim3_axis0_float16_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim3_axis0_float16_all_inputs_as_internal", get_test_model_dim3_axis0_float16_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim3_axis0_quant8() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {3, 2, 2}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({32, 62, 112, 152, 62, 32, 92, 32, 72, 72, 32, 122}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }, { // op2 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {3, 2, 2}, .numberOfConsumers = 0, .scale = 0.0078125f, .zeroPoint = 128, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({128, 205, 230, 230, 205, 128, 205, 128, 230, 230, 128, 205}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim3_axis0_quant8 = TestModelManager::get().add("l2_normalization_axis_dim3_axis0_quant8", get_test_model_dim3_axis0_quant8()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim3_axis0_quant8_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {3, 2, 2}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }, { // op2 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {3, 2, 2}, .numberOfConsumers = 0, .scale = 0.0078125f, .zeroPoint = 128, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({128, 205, 230, 230, 205, 128, 205, 128, 230, 230, 128, 205}) }, { // op1_new .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {3, 2, 2}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({32, 62, 112, 152, 62, 32, 92, 32, 72, 72, 32, 122}) }, { // placeholder35 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({32}) }, { // param35 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim3_axis0_quant8_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim3_axis0_quant8_all_inputs_as_internal", get_test_model_dim3_axis0_quant8_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim3_axis0_neg() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3, 2, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 8.0f, 12.0f, 3.0f, 0.0f, 6.0f, 0.0f, 4.0f, 4.0f, 0.0f, 9.0f}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-3}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3, 2, 2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.8f, 0.8f, 0.6f, 0.0f, 0.6f, 0.0f, 0.8f, 0.8f, 0.0f, 0.6f}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim3_axis0_neg = TestModelManager::get().add("l2_normalization_axis_dim3_axis0_neg", get_test_model_dim3_axis0_neg()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim3_axis0_neg_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3, 2, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-3}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3, 2, 2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.8f, 0.8f, 0.6f, 0.0f, 0.6f, 0.0f, 0.8f, 0.8f, 0.0f, 0.6f}) }, { // op1_new .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3, 2, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 8.0f, 12.0f, 3.0f, 0.0f, 6.0f, 0.0f, 4.0f, 4.0f, 0.0f, 9.0f}) }, { // placeholder36 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f}) }, { // param36 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim3_axis0_neg_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim3_axis0_neg_all_inputs_as_internal", get_test_model_dim3_axis0_neg_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim3_axis0_neg_relaxed() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3, 2, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 8.0f, 12.0f, 3.0f, 0.0f, 6.0f, 0.0f, 4.0f, 4.0f, 0.0f, 9.0f}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-3}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3, 2, 2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.8f, 0.8f, 0.6f, 0.0f, 0.6f, 0.0f, 0.8f, 0.8f, 0.0f, 0.6f}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = true, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::UNKNOWN }; return model; } const auto dummy_test_model_dim3_axis0_neg_relaxed = TestModelManager::get().add("l2_normalization_axis_dim3_axis0_neg_relaxed", get_test_model_dim3_axis0_neg_relaxed()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim3_axis0_neg_relaxed_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3, 2, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-3}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3, 2, 2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.8f, 0.8f, 0.6f, 0.0f, 0.6f, 0.0f, 0.8f, 0.8f, 0.0f, 0.6f}) }, { // op1_new .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3, 2, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 8.0f, 12.0f, 3.0f, 0.0f, 6.0f, 0.0f, 4.0f, 4.0f, 0.0f, 9.0f}) }, { // placeholder37 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f}) }, { // param37 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = true, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::UNKNOWN }; return model; } const auto dummy_test_model_dim3_axis0_neg_relaxed_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim3_axis0_neg_relaxed_all_inputs_as_internal", get_test_model_dim3_axis0_neg_relaxed_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim3_axis0_neg_float16() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {3, 2, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 3.0f, 8.0f, 12.0f, 3.0f, 0.0f, 6.0f, 0.0f, 4.0f, 4.0f, 0.0f, 9.0f}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-3}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {3, 2, 2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 0.6000000238418579f, 0.800000011920929f, 0.800000011920929f, 0.6000000238418579f, 0.0f, 0.6000000238418579f, 0.0f, 0.800000011920929f, 0.800000011920929f, 0.0f, 0.6000000238418579f}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim3_axis0_neg_float16 = TestModelManager::get().add("l2_normalization_axis_dim3_axis0_neg_float16", get_test_model_dim3_axis0_neg_float16()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim3_axis0_neg_float16_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {3, 2, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-3}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {3, 2, 2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 0.6000000238418579f, 0.800000011920929f, 0.800000011920929f, 0.6000000238418579f, 0.0f, 0.6000000238418579f, 0.0f, 0.800000011920929f, 0.800000011920929f, 0.0f, 0.6000000238418579f}) }, { // op1_new .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {3, 2, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 3.0f, 8.0f, 12.0f, 3.0f, 0.0f, 6.0f, 0.0f, 4.0f, 4.0f, 0.0f, 9.0f}) }, { // placeholder38 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f}) }, { // param38 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim3_axis0_neg_float16_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim3_axis0_neg_float16_all_inputs_as_internal", get_test_model_dim3_axis0_neg_float16_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim3_axis0_neg_quant8() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {3, 2, 2}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({32, 62, 112, 152, 62, 32, 92, 32, 72, 72, 32, 122}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-3}) }, { // op2 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {3, 2, 2}, .numberOfConsumers = 0, .scale = 0.0078125f, .zeroPoint = 128, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({128, 205, 230, 230, 205, 128, 205, 128, 230, 230, 128, 205}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim3_axis0_neg_quant8 = TestModelManager::get().add("l2_normalization_axis_dim3_axis0_neg_quant8", get_test_model_dim3_axis0_neg_quant8()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim3_axis0_neg_quant8_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {3, 2, 2}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-3}) }, { // op2 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {3, 2, 2}, .numberOfConsumers = 0, .scale = 0.0078125f, .zeroPoint = 128, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({128, 205, 230, 230, 205, 128, 205, 128, 230, 230, 128, 205}) }, { // op1_new .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {3, 2, 2}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({32, 62, 112, 152, 62, 32, 92, 32, 72, 72, 32, 122}) }, { // placeholder39 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({32}) }, { // param39 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim3_axis0_neg_quant8_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim3_axis0_neg_quant8_all_inputs_as_internal", get_test_model_dim3_axis0_neg_quant8_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim3_axis1() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 3.0f, 0.0f, 4.0f, 4.0f, 8.0f, 12.0f, 6.0f, 0.0f, 0.0f, 9.0f}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({1}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 3, 2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.6f, 0.0f, 0.8f, 0.8f, 0.8f, 0.8f, 0.6f, 0.0f, 0.0f, 0.6f}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim3_axis1 = TestModelManager::get().add("l2_normalization_axis_dim3_axis1", get_test_model_dim3_axis1()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim3_axis1_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({1}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 3, 2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.6f, 0.0f, 0.8f, 0.8f, 0.8f, 0.8f, 0.6f, 0.0f, 0.0f, 0.6f}) }, { // op1_new .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 3.0f, 0.0f, 4.0f, 4.0f, 8.0f, 12.0f, 6.0f, 0.0f, 0.0f, 9.0f}) }, { // placeholder40 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f}) }, { // param40 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim3_axis1_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim3_axis1_all_inputs_as_internal", get_test_model_dim3_axis1_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim3_axis1_relaxed() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 3.0f, 0.0f, 4.0f, 4.0f, 8.0f, 12.0f, 6.0f, 0.0f, 0.0f, 9.0f}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({1}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 3, 2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.6f, 0.0f, 0.8f, 0.8f, 0.8f, 0.8f, 0.6f, 0.0f, 0.0f, 0.6f}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = true, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::UNKNOWN }; return model; } const auto dummy_test_model_dim3_axis1_relaxed = TestModelManager::get().add("l2_normalization_axis_dim3_axis1_relaxed", get_test_model_dim3_axis1_relaxed()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim3_axis1_relaxed_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({1}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 3, 2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.6f, 0.0f, 0.8f, 0.8f, 0.8f, 0.8f, 0.6f, 0.0f, 0.0f, 0.6f}) }, { // op1_new .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 3.0f, 0.0f, 4.0f, 4.0f, 8.0f, 12.0f, 6.0f, 0.0f, 0.0f, 9.0f}) }, { // placeholder41 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f}) }, { // param41 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = true, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::UNKNOWN }; return model; } const auto dummy_test_model_dim3_axis1_relaxed_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim3_axis1_relaxed_all_inputs_as_internal", get_test_model_dim3_axis1_relaxed_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim3_axis1_float16() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {2, 3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 3.0f, 3.0f, 0.0f, 4.0f, 4.0f, 8.0f, 12.0f, 6.0f, 0.0f, 0.0f, 9.0f}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({1}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {2, 3, 2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 0.6000000238418579f, 0.6000000238418579f, 0.0f, 0.800000011920929f, 0.800000011920929f, 0.800000011920929f, 0.800000011920929f, 0.6000000238418579f, 0.0f, 0.0f, 0.6000000238418579f}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim3_axis1_float16 = TestModelManager::get().add("l2_normalization_axis_dim3_axis1_float16", get_test_model_dim3_axis1_float16()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim3_axis1_float16_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {2, 3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({1}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {2, 3, 2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 0.6000000238418579f, 0.6000000238418579f, 0.0f, 0.800000011920929f, 0.800000011920929f, 0.800000011920929f, 0.800000011920929f, 0.6000000238418579f, 0.0f, 0.0f, 0.6000000238418579f}) }, { // op1_new .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {2, 3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 3.0f, 3.0f, 0.0f, 4.0f, 4.0f, 8.0f, 12.0f, 6.0f, 0.0f, 0.0f, 9.0f}) }, { // placeholder42 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f}) }, { // param42 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim3_axis1_float16_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim3_axis1_float16_all_inputs_as_internal", get_test_model_dim3_axis1_float16_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim3_axis1_quant8() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {2, 3, 2}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({32, 62, 62, 32, 72, 72, 112, 152, 92, 32, 32, 122}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({1}) }, { // op2 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {2, 3, 2}, .numberOfConsumers = 0, .scale = 0.0078125f, .zeroPoint = 128, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({128, 205, 205, 128, 230, 230, 230, 230, 205, 128, 128, 205}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim3_axis1_quant8 = TestModelManager::get().add("l2_normalization_axis_dim3_axis1_quant8", get_test_model_dim3_axis1_quant8()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim3_axis1_quant8_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {2, 3, 2}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({1}) }, { // op2 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {2, 3, 2}, .numberOfConsumers = 0, .scale = 0.0078125f, .zeroPoint = 128, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({128, 205, 205, 128, 230, 230, 230, 230, 205, 128, 128, 205}) }, { // op1_new .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {2, 3, 2}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({32, 62, 62, 32, 72, 72, 112, 152, 92, 32, 32, 122}) }, { // placeholder43 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({32}) }, { // param43 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim3_axis1_quant8_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim3_axis1_quant8_all_inputs_as_internal", get_test_model_dim3_axis1_quant8_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim3_axis1_neg() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 3.0f, 0.0f, 4.0f, 4.0f, 8.0f, 12.0f, 6.0f, 0.0f, 0.0f, 9.0f}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-2}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 3, 2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.6f, 0.0f, 0.8f, 0.8f, 0.8f, 0.8f, 0.6f, 0.0f, 0.0f, 0.6f}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim3_axis1_neg = TestModelManager::get().add("l2_normalization_axis_dim3_axis1_neg", get_test_model_dim3_axis1_neg()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim3_axis1_neg_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-2}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 3, 2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.6f, 0.0f, 0.8f, 0.8f, 0.8f, 0.8f, 0.6f, 0.0f, 0.0f, 0.6f}) }, { // op1_new .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 3.0f, 0.0f, 4.0f, 4.0f, 8.0f, 12.0f, 6.0f, 0.0f, 0.0f, 9.0f}) }, { // placeholder44 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f}) }, { // param44 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim3_axis1_neg_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim3_axis1_neg_all_inputs_as_internal", get_test_model_dim3_axis1_neg_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim3_axis1_neg_relaxed() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 3.0f, 0.0f, 4.0f, 4.0f, 8.0f, 12.0f, 6.0f, 0.0f, 0.0f, 9.0f}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-2}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 3, 2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.6f, 0.0f, 0.8f, 0.8f, 0.8f, 0.8f, 0.6f, 0.0f, 0.0f, 0.6f}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = true, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::UNKNOWN }; return model; } const auto dummy_test_model_dim3_axis1_neg_relaxed = TestModelManager::get().add("l2_normalization_axis_dim3_axis1_neg_relaxed", get_test_model_dim3_axis1_neg_relaxed()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim3_axis1_neg_relaxed_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-2}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 3, 2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.6f, 0.0f, 0.8f, 0.8f, 0.8f, 0.8f, 0.6f, 0.0f, 0.0f, 0.6f}) }, { // op1_new .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 3.0f, 0.0f, 4.0f, 4.0f, 8.0f, 12.0f, 6.0f, 0.0f, 0.0f, 9.0f}) }, { // placeholder45 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f}) }, { // param45 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = true, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::UNKNOWN }; return model; } const auto dummy_test_model_dim3_axis1_neg_relaxed_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim3_axis1_neg_relaxed_all_inputs_as_internal", get_test_model_dim3_axis1_neg_relaxed_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim3_axis1_neg_float16() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {2, 3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 3.0f, 3.0f, 0.0f, 4.0f, 4.0f, 8.0f, 12.0f, 6.0f, 0.0f, 0.0f, 9.0f}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-2}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {2, 3, 2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 0.6000000238418579f, 0.6000000238418579f, 0.0f, 0.800000011920929f, 0.800000011920929f, 0.800000011920929f, 0.800000011920929f, 0.6000000238418579f, 0.0f, 0.0f, 0.6000000238418579f}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim3_axis1_neg_float16 = TestModelManager::get().add("l2_normalization_axis_dim3_axis1_neg_float16", get_test_model_dim3_axis1_neg_float16()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim3_axis1_neg_float16_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {2, 3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-2}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {2, 3, 2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 0.6000000238418579f, 0.6000000238418579f, 0.0f, 0.800000011920929f, 0.800000011920929f, 0.800000011920929f, 0.800000011920929f, 0.6000000238418579f, 0.0f, 0.0f, 0.6000000238418579f}) }, { // op1_new .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {2, 3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 3.0f, 3.0f, 0.0f, 4.0f, 4.0f, 8.0f, 12.0f, 6.0f, 0.0f, 0.0f, 9.0f}) }, { // placeholder46 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f}) }, { // param46 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim3_axis1_neg_float16_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim3_axis1_neg_float16_all_inputs_as_internal", get_test_model_dim3_axis1_neg_float16_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim3_axis1_neg_quant8() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {2, 3, 2}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({32, 62, 62, 32, 72, 72, 112, 152, 92, 32, 32, 122}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-2}) }, { // op2 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {2, 3, 2}, .numberOfConsumers = 0, .scale = 0.0078125f, .zeroPoint = 128, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({128, 205, 205, 128, 230, 230, 230, 230, 205, 128, 128, 205}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim3_axis1_neg_quant8 = TestModelManager::get().add("l2_normalization_axis_dim3_axis1_neg_quant8", get_test_model_dim3_axis1_neg_quant8()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim3_axis1_neg_quant8_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {2, 3, 2}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-2}) }, { // op2 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {2, 3, 2}, .numberOfConsumers = 0, .scale = 0.0078125f, .zeroPoint = 128, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({128, 205, 205, 128, 230, 230, 230, 230, 205, 128, 128, 205}) }, { // op1_new .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {2, 3, 2}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({32, 62, 62, 32, 72, 72, 112, 152, 92, 32, 32, 122}) }, { // placeholder47 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({32}) }, { // param47 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim3_axis1_neg_quant8_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim3_axis1_neg_quant8_all_inputs_as_internal", get_test_model_dim3_axis1_neg_quant8_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim3_axis2() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 2, 3}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 4.0f, 3.0f, 0.0f, 4.0f, 8.0f, 6.0f, 0.0f, 12.0f, 0.0f, 9.0f}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({2}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 2, 3}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.8f, 0.6f, 0.0f, 0.8f, 0.8f, 0.6f, 0.0f, 0.8f, 0.0f, 0.6f}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim3_axis2 = TestModelManager::get().add("l2_normalization_axis_dim3_axis2", get_test_model_dim3_axis2()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim3_axis2_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 2, 3}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({2}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 2, 3}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.8f, 0.6f, 0.0f, 0.8f, 0.8f, 0.6f, 0.0f, 0.8f, 0.0f, 0.6f}) }, { // op1_new .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 2, 3}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 4.0f, 3.0f, 0.0f, 4.0f, 8.0f, 6.0f, 0.0f, 12.0f, 0.0f, 9.0f}) }, { // placeholder48 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f}) }, { // param48 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim3_axis2_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim3_axis2_all_inputs_as_internal", get_test_model_dim3_axis2_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim3_axis2_relaxed() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 2, 3}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 4.0f, 3.0f, 0.0f, 4.0f, 8.0f, 6.0f, 0.0f, 12.0f, 0.0f, 9.0f}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({2}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 2, 3}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.8f, 0.6f, 0.0f, 0.8f, 0.8f, 0.6f, 0.0f, 0.8f, 0.0f, 0.6f}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = true, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::UNKNOWN }; return model; } const auto dummy_test_model_dim3_axis2_relaxed = TestModelManager::get().add("l2_normalization_axis_dim3_axis2_relaxed", get_test_model_dim3_axis2_relaxed()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim3_axis2_relaxed_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 2, 3}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({2}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 2, 3}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.8f, 0.6f, 0.0f, 0.8f, 0.8f, 0.6f, 0.0f, 0.8f, 0.0f, 0.6f}) }, { // op1_new .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 2, 3}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 4.0f, 3.0f, 0.0f, 4.0f, 8.0f, 6.0f, 0.0f, 12.0f, 0.0f, 9.0f}) }, { // placeholder49 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f}) }, { // param49 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = true, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::UNKNOWN }; return model; } const auto dummy_test_model_dim3_axis2_relaxed_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim3_axis2_relaxed_all_inputs_as_internal", get_test_model_dim3_axis2_relaxed_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim3_axis2_float16() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {2, 2, 3}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 3.0f, 4.0f, 3.0f, 0.0f, 4.0f, 8.0f, 6.0f, 0.0f, 12.0f, 0.0f, 9.0f}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({2}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {2, 2, 3}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 0.6000000238418579f, 0.800000011920929f, 0.6000000238418579f, 0.0f, 0.800000011920929f, 0.800000011920929f, 0.6000000238418579f, 0.0f, 0.800000011920929f, 0.0f, 0.6000000238418579f}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim3_axis2_float16 = TestModelManager::get().add("l2_normalization_axis_dim3_axis2_float16", get_test_model_dim3_axis2_float16()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim3_axis2_float16_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {2, 2, 3}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({2}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {2, 2, 3}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 0.6000000238418579f, 0.800000011920929f, 0.6000000238418579f, 0.0f, 0.800000011920929f, 0.800000011920929f, 0.6000000238418579f, 0.0f, 0.800000011920929f, 0.0f, 0.6000000238418579f}) }, { // op1_new .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {2, 2, 3}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 3.0f, 4.0f, 3.0f, 0.0f, 4.0f, 8.0f, 6.0f, 0.0f, 12.0f, 0.0f, 9.0f}) }, { // placeholder50 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f}) }, { // param50 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim3_axis2_float16_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim3_axis2_float16_all_inputs_as_internal", get_test_model_dim3_axis2_float16_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim3_axis2_quant8() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {2, 2, 3}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({32, 62, 72, 62, 32, 72, 112, 92, 32, 152, 32, 122}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({2}) }, { // op2 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {2, 2, 3}, .numberOfConsumers = 0, .scale = 0.0078125f, .zeroPoint = 128, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({128, 205, 230, 205, 128, 230, 230, 205, 128, 230, 128, 205}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim3_axis2_quant8 = TestModelManager::get().add("l2_normalization_axis_dim3_axis2_quant8", get_test_model_dim3_axis2_quant8()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim3_axis2_quant8_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {2, 2, 3}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({2}) }, { // op2 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {2, 2, 3}, .numberOfConsumers = 0, .scale = 0.0078125f, .zeroPoint = 128, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({128, 205, 230, 205, 128, 230, 230, 205, 128, 230, 128, 205}) }, { // op1_new .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {2, 2, 3}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({32, 62, 72, 62, 32, 72, 112, 92, 32, 152, 32, 122}) }, { // placeholder51 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({32}) }, { // param51 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim3_axis2_quant8_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim3_axis2_quant8_all_inputs_as_internal", get_test_model_dim3_axis2_quant8_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim3_axis2_neg() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 2, 3}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 4.0f, 3.0f, 0.0f, 4.0f, 8.0f, 6.0f, 0.0f, 12.0f, 0.0f, 9.0f}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-1}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 2, 3}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.8f, 0.6f, 0.0f, 0.8f, 0.8f, 0.6f, 0.0f, 0.8f, 0.0f, 0.6f}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim3_axis2_neg = TestModelManager::get().add("l2_normalization_axis_dim3_axis2_neg", get_test_model_dim3_axis2_neg()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim3_axis2_neg_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 2, 3}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-1}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 2, 3}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.8f, 0.6f, 0.0f, 0.8f, 0.8f, 0.6f, 0.0f, 0.8f, 0.0f, 0.6f}) }, { // op1_new .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 2, 3}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 4.0f, 3.0f, 0.0f, 4.0f, 8.0f, 6.0f, 0.0f, 12.0f, 0.0f, 9.0f}) }, { // placeholder52 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f}) }, { // param52 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim3_axis2_neg_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim3_axis2_neg_all_inputs_as_internal", get_test_model_dim3_axis2_neg_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim3_axis2_neg_relaxed() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 2, 3}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 4.0f, 3.0f, 0.0f, 4.0f, 8.0f, 6.0f, 0.0f, 12.0f, 0.0f, 9.0f}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-1}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 2, 3}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.8f, 0.6f, 0.0f, 0.8f, 0.8f, 0.6f, 0.0f, 0.8f, 0.0f, 0.6f}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = true, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::UNKNOWN }; return model; } const auto dummy_test_model_dim3_axis2_neg_relaxed = TestModelManager::get().add("l2_normalization_axis_dim3_axis2_neg_relaxed", get_test_model_dim3_axis2_neg_relaxed()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim3_axis2_neg_relaxed_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 2, 3}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-1}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 2, 3}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.8f, 0.6f, 0.0f, 0.8f, 0.8f, 0.6f, 0.0f, 0.8f, 0.0f, 0.6f}) }, { // op1_new .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 2, 3}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 4.0f, 3.0f, 0.0f, 4.0f, 8.0f, 6.0f, 0.0f, 12.0f, 0.0f, 9.0f}) }, { // placeholder53 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f}) }, { // param53 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = true, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::UNKNOWN }; return model; } const auto dummy_test_model_dim3_axis2_neg_relaxed_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim3_axis2_neg_relaxed_all_inputs_as_internal", get_test_model_dim3_axis2_neg_relaxed_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim3_axis2_neg_float16() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {2, 2, 3}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 3.0f, 4.0f, 3.0f, 0.0f, 4.0f, 8.0f, 6.0f, 0.0f, 12.0f, 0.0f, 9.0f}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-1}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {2, 2, 3}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 0.6000000238418579f, 0.800000011920929f, 0.6000000238418579f, 0.0f, 0.800000011920929f, 0.800000011920929f, 0.6000000238418579f, 0.0f, 0.800000011920929f, 0.0f, 0.6000000238418579f}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim3_axis2_neg_float16 = TestModelManager::get().add("l2_normalization_axis_dim3_axis2_neg_float16", get_test_model_dim3_axis2_neg_float16()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim3_axis2_neg_float16_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {2, 2, 3}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-1}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {2, 2, 3}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 0.6000000238418579f, 0.800000011920929f, 0.6000000238418579f, 0.0f, 0.800000011920929f, 0.800000011920929f, 0.6000000238418579f, 0.0f, 0.800000011920929f, 0.0f, 0.6000000238418579f}) }, { // op1_new .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {2, 2, 3}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 3.0f, 4.0f, 3.0f, 0.0f, 4.0f, 8.0f, 6.0f, 0.0f, 12.0f, 0.0f, 9.0f}) }, { // placeholder54 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f}) }, { // param54 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim3_axis2_neg_float16_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim3_axis2_neg_float16_all_inputs_as_internal", get_test_model_dim3_axis2_neg_float16_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim3_axis2_neg_quant8() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {2, 2, 3}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({32, 62, 72, 62, 32, 72, 112, 92, 32, 152, 32, 122}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-1}) }, { // op2 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {2, 2, 3}, .numberOfConsumers = 0, .scale = 0.0078125f, .zeroPoint = 128, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({128, 205, 230, 205, 128, 230, 230, 205, 128, 230, 128, 205}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim3_axis2_neg_quant8 = TestModelManager::get().add("l2_normalization_axis_dim3_axis2_neg_quant8", get_test_model_dim3_axis2_neg_quant8()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim3_axis2_neg_quant8_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {2, 2, 3}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-1}) }, { // op2 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {2, 2, 3}, .numberOfConsumers = 0, .scale = 0.0078125f, .zeroPoint = 128, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({128, 205, 230, 205, 128, 230, 230, 205, 128, 230, 128, 205}) }, { // op1_new .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {2, 2, 3}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({32, 62, 72, 62, 32, 72, 112, 92, 32, 152, 32, 122}) }, { // placeholder55 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({32}) }, { // param55 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim3_axis2_neg_quant8_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim3_axis2_neg_quant8_all_inputs_as_internal", get_test_model_dim3_axis2_neg_quant8_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim2_axis0() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 3.0f, 0.0f, 4.0f, 4.0f}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3, 2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.6f, 0.0f, 0.8f, 0.8f}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim2_axis0 = TestModelManager::get().add("l2_normalization_axis_dim2_axis0", get_test_model_dim2_axis0()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim2_axis0_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3, 2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.6f, 0.0f, 0.8f, 0.8f}) }, { // op1_new .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 3.0f, 0.0f, 4.0f, 4.0f}) }, { // placeholder56 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f}) }, { // param56 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim2_axis0_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim2_axis0_all_inputs_as_internal", get_test_model_dim2_axis0_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim2_axis0_relaxed() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 3.0f, 0.0f, 4.0f, 4.0f}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3, 2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.6f, 0.0f, 0.8f, 0.8f}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = true, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::UNKNOWN }; return model; } const auto dummy_test_model_dim2_axis0_relaxed = TestModelManager::get().add("l2_normalization_axis_dim2_axis0_relaxed", get_test_model_dim2_axis0_relaxed()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim2_axis0_relaxed_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3, 2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.6f, 0.0f, 0.8f, 0.8f}) }, { // op1_new .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 3.0f, 0.0f, 4.0f, 4.0f}) }, { // placeholder57 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f}) }, { // param57 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = true, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::UNKNOWN }; return model; } const auto dummy_test_model_dim2_axis0_relaxed_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim2_axis0_relaxed_all_inputs_as_internal", get_test_model_dim2_axis0_relaxed_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim2_axis0_float16() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 3.0f, 3.0f, 0.0f, 4.0f, 4.0f}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {3, 2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 0.6000000238418579f, 0.6000000238418579f, 0.0f, 0.800000011920929f, 0.800000011920929f}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim2_axis0_float16 = TestModelManager::get().add("l2_normalization_axis_dim2_axis0_float16", get_test_model_dim2_axis0_float16()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim2_axis0_float16_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {3, 2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 0.6000000238418579f, 0.6000000238418579f, 0.0f, 0.800000011920929f, 0.800000011920929f}) }, { // op1_new .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 3.0f, 3.0f, 0.0f, 4.0f, 4.0f}) }, { // placeholder58 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f}) }, { // param58 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim2_axis0_float16_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim2_axis0_float16_all_inputs_as_internal", get_test_model_dim2_axis0_float16_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim2_axis0_quant8() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {3, 2}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({32, 62, 62, 32, 72, 72}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }, { // op2 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {3, 2}, .numberOfConsumers = 0, .scale = 0.0078125f, .zeroPoint = 128, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({128, 205, 205, 128, 230, 230}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim2_axis0_quant8 = TestModelManager::get().add("l2_normalization_axis_dim2_axis0_quant8", get_test_model_dim2_axis0_quant8()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim2_axis0_quant8_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {3, 2}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }, { // op2 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {3, 2}, .numberOfConsumers = 0, .scale = 0.0078125f, .zeroPoint = 128, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({128, 205, 205, 128, 230, 230}) }, { // op1_new .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {3, 2}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({32, 62, 62, 32, 72, 72}) }, { // placeholder59 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({32}) }, { // param59 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim2_axis0_quant8_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim2_axis0_quant8_all_inputs_as_internal", get_test_model_dim2_axis0_quant8_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim2_axis0_neg() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 3.0f, 0.0f, 4.0f, 4.0f}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-2}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3, 2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.6f, 0.0f, 0.8f, 0.8f}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim2_axis0_neg = TestModelManager::get().add("l2_normalization_axis_dim2_axis0_neg", get_test_model_dim2_axis0_neg()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim2_axis0_neg_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-2}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3, 2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.6f, 0.0f, 0.8f, 0.8f}) }, { // op1_new .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 3.0f, 0.0f, 4.0f, 4.0f}) }, { // placeholder60 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f}) }, { // param60 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim2_axis0_neg_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim2_axis0_neg_all_inputs_as_internal", get_test_model_dim2_axis0_neg_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim2_axis0_neg_relaxed() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 3.0f, 0.0f, 4.0f, 4.0f}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-2}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3, 2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.6f, 0.0f, 0.8f, 0.8f}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = true, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::UNKNOWN }; return model; } const auto dummy_test_model_dim2_axis0_neg_relaxed = TestModelManager::get().add("l2_normalization_axis_dim2_axis0_neg_relaxed", get_test_model_dim2_axis0_neg_relaxed()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim2_axis0_neg_relaxed_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-2}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3, 2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.6f, 0.0f, 0.8f, 0.8f}) }, { // op1_new .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 3.0f, 0.0f, 4.0f, 4.0f}) }, { // placeholder61 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f}) }, { // param61 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = true, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::UNKNOWN }; return model; } const auto dummy_test_model_dim2_axis0_neg_relaxed_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim2_axis0_neg_relaxed_all_inputs_as_internal", get_test_model_dim2_axis0_neg_relaxed_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim2_axis0_neg_float16() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 3.0f, 3.0f, 0.0f, 4.0f, 4.0f}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-2}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {3, 2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 0.6000000238418579f, 0.6000000238418579f, 0.0f, 0.800000011920929f, 0.800000011920929f}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim2_axis0_neg_float16 = TestModelManager::get().add("l2_normalization_axis_dim2_axis0_neg_float16", get_test_model_dim2_axis0_neg_float16()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim2_axis0_neg_float16_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-2}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {3, 2}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 0.6000000238418579f, 0.6000000238418579f, 0.0f, 0.800000011920929f, 0.800000011920929f}) }, { // op1_new .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {3, 2}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 3.0f, 3.0f, 0.0f, 4.0f, 4.0f}) }, { // placeholder62 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f}) }, { // param62 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim2_axis0_neg_float16_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim2_axis0_neg_float16_all_inputs_as_internal", get_test_model_dim2_axis0_neg_float16_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim2_axis0_neg_quant8() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {3, 2}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({32, 62, 62, 32, 72, 72}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-2}) }, { // op2 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {3, 2}, .numberOfConsumers = 0, .scale = 0.0078125f, .zeroPoint = 128, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({128, 205, 205, 128, 230, 230}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim2_axis0_neg_quant8 = TestModelManager::get().add("l2_normalization_axis_dim2_axis0_neg_quant8", get_test_model_dim2_axis0_neg_quant8()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim2_axis0_neg_quant8_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {3, 2}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-2}) }, { // op2 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {3, 2}, .numberOfConsumers = 0, .scale = 0.0078125f, .zeroPoint = 128, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({128, 205, 205, 128, 230, 230}) }, { // op1_new .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {3, 2}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({32, 62, 62, 32, 72, 72}) }, { // placeholder63 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({32}) }, { // param63 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim2_axis0_neg_quant8_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim2_axis0_neg_quant8_all_inputs_as_internal", get_test_model_dim2_axis0_neg_quant8_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim2_axis1() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 3}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 4.0f, 3.0f, 0.0f, 4.0f}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({1}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 3}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.8f, 0.6f, 0.0f, 0.8f}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim2_axis1 = TestModelManager::get().add("l2_normalization_axis_dim2_axis1", get_test_model_dim2_axis1()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim2_axis1_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 3}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({1}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 3}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.8f, 0.6f, 0.0f, 0.8f}) }, { // op1_new .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 3}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 4.0f, 3.0f, 0.0f, 4.0f}) }, { // placeholder64 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f}) }, { // param64 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim2_axis1_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim2_axis1_all_inputs_as_internal", get_test_model_dim2_axis1_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim2_axis1_relaxed() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 3}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 4.0f, 3.0f, 0.0f, 4.0f}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({1}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 3}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.8f, 0.6f, 0.0f, 0.8f}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = true, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::UNKNOWN }; return model; } const auto dummy_test_model_dim2_axis1_relaxed = TestModelManager::get().add("l2_normalization_axis_dim2_axis1_relaxed", get_test_model_dim2_axis1_relaxed()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim2_axis1_relaxed_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 3}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({1}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 3}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.8f, 0.6f, 0.0f, 0.8f}) }, { // op1_new .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 3}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 4.0f, 3.0f, 0.0f, 4.0f}) }, { // placeholder65 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f}) }, { // param65 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = true, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::UNKNOWN }; return model; } const auto dummy_test_model_dim2_axis1_relaxed_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim2_axis1_relaxed_all_inputs_as_internal", get_test_model_dim2_axis1_relaxed_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim2_axis1_float16() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {2, 3}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 3.0f, 4.0f, 3.0f, 0.0f, 4.0f}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({1}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {2, 3}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 0.6000000238418579f, 0.800000011920929f, 0.6000000238418579f, 0.0f, 0.800000011920929f}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim2_axis1_float16 = TestModelManager::get().add("l2_normalization_axis_dim2_axis1_float16", get_test_model_dim2_axis1_float16()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim2_axis1_float16_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {2, 3}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({1}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {2, 3}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 0.6000000238418579f, 0.800000011920929f, 0.6000000238418579f, 0.0f, 0.800000011920929f}) }, { // op1_new .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {2, 3}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 3.0f, 4.0f, 3.0f, 0.0f, 4.0f}) }, { // placeholder66 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f}) }, { // param66 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim2_axis1_float16_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim2_axis1_float16_all_inputs_as_internal", get_test_model_dim2_axis1_float16_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim2_axis1_quant8() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {2, 3}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({32, 62, 72, 62, 32, 72}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({1}) }, { // op2 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {2, 3}, .numberOfConsumers = 0, .scale = 0.0078125f, .zeroPoint = 128, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({128, 205, 230, 205, 128, 230}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim2_axis1_quant8 = TestModelManager::get().add("l2_normalization_axis_dim2_axis1_quant8", get_test_model_dim2_axis1_quant8()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim2_axis1_quant8_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {2, 3}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({1}) }, { // op2 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {2, 3}, .numberOfConsumers = 0, .scale = 0.0078125f, .zeroPoint = 128, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({128, 205, 230, 205, 128, 230}) }, { // op1_new .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {2, 3}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({32, 62, 72, 62, 32, 72}) }, { // placeholder67 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({32}) }, { // param67 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim2_axis1_quant8_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim2_axis1_quant8_all_inputs_as_internal", get_test_model_dim2_axis1_quant8_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim2_axis1_neg() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 3}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 4.0f, 3.0f, 0.0f, 4.0f}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-1}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 3}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.8f, 0.6f, 0.0f, 0.8f}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim2_axis1_neg = TestModelManager::get().add("l2_normalization_axis_dim2_axis1_neg", get_test_model_dim2_axis1_neg()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim2_axis1_neg_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 3}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-1}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 3}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.8f, 0.6f, 0.0f, 0.8f}) }, { // op1_new .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 3}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 4.0f, 3.0f, 0.0f, 4.0f}) }, { // placeholder68 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f}) }, { // param68 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim2_axis1_neg_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim2_axis1_neg_all_inputs_as_internal", get_test_model_dim2_axis1_neg_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim2_axis1_neg_relaxed() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 3}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 4.0f, 3.0f, 0.0f, 4.0f}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-1}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 3}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.8f, 0.6f, 0.0f, 0.8f}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = true, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::UNKNOWN }; return model; } const auto dummy_test_model_dim2_axis1_neg_relaxed = TestModelManager::get().add("l2_normalization_axis_dim2_axis1_neg_relaxed", get_test_model_dim2_axis1_neg_relaxed()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim2_axis1_neg_relaxed_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 3}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-1}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 3}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.8f, 0.6f, 0.0f, 0.8f}) }, { // op1_new .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {2, 3}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 4.0f, 3.0f, 0.0f, 4.0f}) }, { // placeholder69 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f}) }, { // param69 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = true, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::UNKNOWN }; return model; } const auto dummy_test_model_dim2_axis1_neg_relaxed_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim2_axis1_neg_relaxed_all_inputs_as_internal", get_test_model_dim2_axis1_neg_relaxed_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim2_axis1_neg_float16() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {2, 3}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 3.0f, 4.0f, 3.0f, 0.0f, 4.0f}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-1}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {2, 3}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 0.6000000238418579f, 0.800000011920929f, 0.6000000238418579f, 0.0f, 0.800000011920929f}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim2_axis1_neg_float16 = TestModelManager::get().add("l2_normalization_axis_dim2_axis1_neg_float16", get_test_model_dim2_axis1_neg_float16()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim2_axis1_neg_float16_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {2, 3}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-1}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {2, 3}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 0.6000000238418579f, 0.800000011920929f, 0.6000000238418579f, 0.0f, 0.800000011920929f}) }, { // op1_new .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {2, 3}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 3.0f, 4.0f, 3.0f, 0.0f, 4.0f}) }, { // placeholder70 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f}) }, { // param70 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim2_axis1_neg_float16_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim2_axis1_neg_float16_all_inputs_as_internal", get_test_model_dim2_axis1_neg_float16_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim2_axis1_neg_quant8() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {2, 3}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({32, 62, 72, 62, 32, 72}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-1}) }, { // op2 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {2, 3}, .numberOfConsumers = 0, .scale = 0.0078125f, .zeroPoint = 128, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({128, 205, 230, 205, 128, 230}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim2_axis1_neg_quant8 = TestModelManager::get().add("l2_normalization_axis_dim2_axis1_neg_quant8", get_test_model_dim2_axis1_neg_quant8()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim2_axis1_neg_quant8_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {2, 3}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-1}) }, { // op2 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {2, 3}, .numberOfConsumers = 0, .scale = 0.0078125f, .zeroPoint = 128, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({128, 205, 230, 205, 128, 230}) }, { // op1_new .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {2, 3}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({32, 62, 72, 62, 32, 72}) }, { // placeholder71 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({32}) }, { // param71 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim2_axis1_neg_quant8_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim2_axis1_neg_quant8_all_inputs_as_internal", get_test_model_dim2_axis1_neg_quant8_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim1_axis0() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 4.0f}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.8f}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim1_axis0 = TestModelManager::get().add("l2_normalization_axis_dim1_axis0", get_test_model_dim1_axis0()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim1_axis0_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.8f}) }, { // op1_new .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 4.0f}) }, { // placeholder72 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f}) }, { // param72 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim1_axis0_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim1_axis0_all_inputs_as_internal", get_test_model_dim1_axis0_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim1_axis0_relaxed() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 4.0f}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.8f}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = true, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::UNKNOWN }; return model; } const auto dummy_test_model_dim1_axis0_relaxed = TestModelManager::get().add("l2_normalization_axis_dim1_axis0_relaxed", get_test_model_dim1_axis0_relaxed()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim1_axis0_relaxed_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.8f}) }, { // op1_new .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 4.0f}) }, { // placeholder73 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f}) }, { // param73 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = true, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::UNKNOWN }; return model; } const auto dummy_test_model_dim1_axis0_relaxed_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim1_axis0_relaxed_all_inputs_as_internal", get_test_model_dim1_axis0_relaxed_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim1_axis0_float16() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {3}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 3.0f, 4.0f}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {3}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 0.6000000238418579f, 0.800000011920929f}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim1_axis0_float16 = TestModelManager::get().add("l2_normalization_axis_dim1_axis0_float16", get_test_model_dim1_axis0_float16()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim1_axis0_float16_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {3}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {3}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 0.6000000238418579f, 0.800000011920929f}) }, { // op1_new .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {3}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 3.0f, 4.0f}) }, { // placeholder74 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f}) }, { // param74 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim1_axis0_float16_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim1_axis0_float16_all_inputs_as_internal", get_test_model_dim1_axis0_float16_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim1_axis0_quant8() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {3}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({32, 62, 72}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }, { // op2 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {3}, .numberOfConsumers = 0, .scale = 0.0078125f, .zeroPoint = 128, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({128, 205, 230}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim1_axis0_quant8 = TestModelManager::get().add("l2_normalization_axis_dim1_axis0_quant8", get_test_model_dim1_axis0_quant8()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim1_axis0_quant8_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {3}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }, { // op2 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {3}, .numberOfConsumers = 0, .scale = 0.0078125f, .zeroPoint = 128, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({128, 205, 230}) }, { // op1_new .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {3}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({32, 62, 72}) }, { // placeholder75 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({32}) }, { // param75 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim1_axis0_quant8_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim1_axis0_quant8_all_inputs_as_internal", get_test_model_dim1_axis0_quant8_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim1_axis0_neg() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 4.0f}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-1}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.8f}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim1_axis0_neg = TestModelManager::get().add("l2_normalization_axis_dim1_axis0_neg", get_test_model_dim1_axis0_neg()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim1_axis0_neg_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-1}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.8f}) }, { // op1_new .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 4.0f}) }, { // placeholder76 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f}) }, { // param76 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim1_axis0_neg_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim1_axis0_neg_all_inputs_as_internal", get_test_model_dim1_axis0_neg_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim1_axis0_neg_relaxed() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 4.0f}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-1}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.8f}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = true, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::UNKNOWN }; return model; } const auto dummy_test_model_dim1_axis0_neg_relaxed = TestModelManager::get().add("l2_normalization_axis_dim1_axis0_neg_relaxed", get_test_model_dim1_axis0_neg_relaxed()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim1_axis0_neg_relaxed_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-1}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 0.6f, 0.8f}) }, { // op1_new .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {3}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f, 3.0f, 4.0f}) }, { // placeholder77 .type = TestOperandType::TENSOR_FLOAT32, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0.0f}) }, { // param77 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = true, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::UNKNOWN }; return model; } const auto dummy_test_model_dim1_axis0_neg_relaxed_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim1_axis0_neg_relaxed_all_inputs_as_internal", get_test_model_dim1_axis0_neg_relaxed_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim1_axis0_neg_float16() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {3}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 3.0f, 4.0f}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-1}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {3}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 0.6000000238418579f, 0.800000011920929f}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim1_axis0_neg_float16 = TestModelManager::get().add("l2_normalization_axis_dim1_axis0_neg_float16", get_test_model_dim1_axis0_neg_float16()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim1_axis0_neg_float16_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {3}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-1}) }, { // op2 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {3}, .numberOfConsumers = 0, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 0.6000000238418579f, 0.800000011920929f}) }, { // op1_new .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {3}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f, 3.0f, 4.0f}) }, { // placeholder78 .type = TestOperandType::TENSOR_FLOAT16, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector<_Float16>({0.0f}) }, { // param78 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim1_axis0_neg_float16_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim1_axis0_neg_float16_all_inputs_as_internal", get_test_model_dim1_axis0_neg_float16_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim1_axis0_neg_quant8() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {3}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({32, 62, 72}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-1}) }, { // op2 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {3}, .numberOfConsumers = 0, .scale = 0.0078125f, .zeroPoint = 128, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({128, 205, 230}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim1_axis0_neg_quant8 = TestModelManager::get().add("l2_normalization_axis_dim1_axis0_neg_quant8", get_test_model_dim1_axis0_neg_quant8()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_dim1_axis0_neg_quant8_all_inputs_as_internal() { static TestModel model = { .main = { .operands = {{ // op1 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {3}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // axis .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-1}) }, { // op2 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {3}, .numberOfConsumers = 0, .scale = 0.0078125f, .zeroPoint = 128, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({128, 205, 230}) }, { // op1_new .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {3}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({32, 62, 72}) }, { // placeholder79 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.1f, .zeroPoint = 32, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({32}) }, { // param79 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_dim1_axis0_neg_quant8_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_dim1_axis0_neg_quant8_all_inputs_as_internal", get_test_model_dim1_axis0_neg_quant8_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_corner_case_dim2_axis0() { static TestModel model = { .main = { // corner_case .operands = {{ // op11 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {1, 2}, .numberOfConsumers = 1, .scale = 0.904414f, .zeroPoint = 246, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({245, 247}) }, { // axis1 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }, { // op21 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {1, 2}, .numberOfConsumers = 0, .scale = 0.0078125f, .zeroPoint = 128, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0, 255}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_corner_case_dim2_axis0 = TestModelManager::get().add("l2_normalization_axis_corner_case_dim2_axis0", get_test_model_corner_case_dim2_axis0()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_corner_case_dim2_axis0_all_inputs_as_internal() { static TestModel model = { .main = { // corner_case .operands = {{ // op11 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {1, 2}, .numberOfConsumers = 1, .scale = 0.904414f, .zeroPoint = 246, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // axis1 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }, { // op21 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {1, 2}, .numberOfConsumers = 0, .scale = 0.0078125f, .zeroPoint = 128, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0, 255}) }, { // op11_new .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {1, 2}, .numberOfConsumers = 1, .scale = 0.904414f, .zeroPoint = 246, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({245, 247}) }, { // placeholder80 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.904414f, .zeroPoint = 246, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({246}) }, { // param80 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_corner_case_dim2_axis0_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_corner_case_dim2_axis0_all_inputs_as_internal", get_test_model_corner_case_dim2_axis0_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_corner_case_dim2_axis0_neg() { static TestModel model = { .main = { // corner_case .operands = {{ // op11 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {1, 2}, .numberOfConsumers = 1, .scale = 0.904414f, .zeroPoint = 246, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({245, 247}) }, { // axis1 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-2}) }, { // op21 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {1, 2}, .numberOfConsumers = 0, .scale = 0.0078125f, .zeroPoint = 128, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0, 255}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_corner_case_dim2_axis0_neg = TestModelManager::get().add("l2_normalization_axis_corner_case_dim2_axis0_neg", get_test_model_corner_case_dim2_axis0_neg()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_corner_case_dim2_axis0_neg_all_inputs_as_internal() { static TestModel model = { .main = { // corner_case .operands = {{ // op11 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {1, 2}, .numberOfConsumers = 1, .scale = 0.904414f, .zeroPoint = 246, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // axis1 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-2}) }, { // op21 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {1, 2}, .numberOfConsumers = 0, .scale = 0.0078125f, .zeroPoint = 128, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0, 255}) }, { // op11_new .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {1, 2}, .numberOfConsumers = 1, .scale = 0.904414f, .zeroPoint = 246, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({245, 247}) }, { // placeholder81 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.904414f, .zeroPoint = 246, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({246}) }, { // param81 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_corner_case_dim2_axis0_neg_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_corner_case_dim2_axis0_neg_all_inputs_as_internal", get_test_model_corner_case_dim2_axis0_neg_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_corner_case_dim2_axis1() { static TestModel model = { .main = { // corner_case .operands = {{ // op11 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {2, 1}, .numberOfConsumers = 1, .scale = 0.904414f, .zeroPoint = 246, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({245, 247}) }, { // axis1 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({1}) }, { // op21 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {2, 1}, .numberOfConsumers = 0, .scale = 0.0078125f, .zeroPoint = 128, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0, 255}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_corner_case_dim2_axis1 = TestModelManager::get().add("l2_normalization_axis_corner_case_dim2_axis1", get_test_model_corner_case_dim2_axis1()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_corner_case_dim2_axis1_all_inputs_as_internal() { static TestModel model = { .main = { // corner_case .operands = {{ // op11 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {2, 1}, .numberOfConsumers = 1, .scale = 0.904414f, .zeroPoint = 246, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // axis1 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({1}) }, { // op21 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {2, 1}, .numberOfConsumers = 0, .scale = 0.0078125f, .zeroPoint = 128, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0, 255}) }, { // op11_new .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {2, 1}, .numberOfConsumers = 1, .scale = 0.904414f, .zeroPoint = 246, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({245, 247}) }, { // placeholder82 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.904414f, .zeroPoint = 246, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({246}) }, { // param82 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_corner_case_dim2_axis1_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_corner_case_dim2_axis1_all_inputs_as_internal", get_test_model_corner_case_dim2_axis1_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_corner_case_dim2_axis1_neg() { static TestModel model = { .main = { // corner_case .operands = {{ // op11 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {2, 1}, .numberOfConsumers = 1, .scale = 0.904414f, .zeroPoint = 246, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({245, 247}) }, { // axis1 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-1}) }, { // op21 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {2, 1}, .numberOfConsumers = 0, .scale = 0.0078125f, .zeroPoint = 128, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0, 255}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_corner_case_dim2_axis1_neg = TestModelManager::get().add("l2_normalization_axis_corner_case_dim2_axis1_neg", get_test_model_corner_case_dim2_axis1_neg()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_corner_case_dim2_axis1_neg_all_inputs_as_internal() { static TestModel model = { .main = { // corner_case .operands = {{ // op11 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {2, 1}, .numberOfConsumers = 1, .scale = 0.904414f, .zeroPoint = 246, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // axis1 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-1}) }, { // op21 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {2, 1}, .numberOfConsumers = 0, .scale = 0.0078125f, .zeroPoint = 128, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0, 255}) }, { // op11_new .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {2, 1}, .numberOfConsumers = 1, .scale = 0.904414f, .zeroPoint = 246, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({245, 247}) }, { // placeholder83 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.904414f, .zeroPoint = 246, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({246}) }, { // param83 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_corner_case_dim2_axis1_neg_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_corner_case_dim2_axis1_neg_all_inputs_as_internal", get_test_model_corner_case_dim2_axis1_neg_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_corner_case_dim1_axis0() { static TestModel model = { .main = { // corner_case .operands = {{ // op11 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.904414f, .zeroPoint = 246, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({245}) }, { // axis1 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }, { // op21 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {1}, .numberOfConsumers = 0, .scale = 0.0078125f, .zeroPoint = 128, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_corner_case_dim1_axis0 = TestModelManager::get().add("l2_normalization_axis_corner_case_dim1_axis0", get_test_model_corner_case_dim1_axis0()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_corner_case_dim1_axis0_all_inputs_as_internal() { static TestModel model = { .main = { // corner_case .operands = {{ // op11 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.904414f, .zeroPoint = 246, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // axis1 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }, { // op21 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {1}, .numberOfConsumers = 0, .scale = 0.0078125f, .zeroPoint = 128, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }, { // op11_new .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.904414f, .zeroPoint = 246, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({245}) }, { // placeholder84 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.904414f, .zeroPoint = 246, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({246}) }, { // param84 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_corner_case_dim1_axis0_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_corner_case_dim1_axis0_all_inputs_as_internal", get_test_model_corner_case_dim1_axis0_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_corner_case_dim1_axis0_neg() { static TestModel model = { .main = { // corner_case .operands = {{ // op11 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.904414f, .zeroPoint = 246, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({245}) }, { // axis1 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-1}) }, { // op21 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {1}, .numberOfConsumers = 0, .scale = 0.0078125f, .zeroPoint = 128, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {0}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_corner_case_dim1_axis0_neg = TestModelManager::get().add("l2_normalization_axis_corner_case_dim1_axis0_neg", get_test_model_corner_case_dim1_axis0_neg()); } // namespace generated_tests::l2_normalization_axis namespace generated_tests::l2_normalization_axis { const TestModel& get_test_model_corner_case_dim1_axis0_neg_all_inputs_as_internal() { static TestModel model = { .main = { // corner_case .operands = {{ // op11 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.904414f, .zeroPoint = 246, .lifetime = TestOperandLifeTime::TEMPORARY_VARIABLE, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({}) }, { // axis1 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({-1}) }, { // op21 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {1}, .numberOfConsumers = 0, .scale = 0.0078125f, .zeroPoint = 128, .lifetime = TestOperandLifeTime::SUBGRAPH_OUTPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }, { // op11_new .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.904414f, .zeroPoint = 246, .lifetime = TestOperandLifeTime::SUBGRAPH_INPUT, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({245}) }, { // placeholder85 .type = TestOperandType::TENSOR_QUANT8_ASYMM, .dimensions = {1}, .numberOfConsumers = 1, .scale = 0.904414f, .zeroPoint = 246, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({246}) }, { // param85 .type = TestOperandType::INT32, .dimensions = {}, .numberOfConsumers = 1, .scale = 0.0f, .zeroPoint = 0, .lifetime = TestOperandLifeTime::CONSTANT_COPY, .channelQuant = {}, .isIgnored = false, .data = TestBuffer::createFromVector({0}) }}, .operations = {{ .type = TestOperationType::ADD, .inputs = {3, 4, 5}, .outputs = {0} }, { .type = TestOperationType::L2_NORMALIZATION, .inputs = {0, 1}, .outputs = {2} }}, .inputIndexes = {3}, .outputIndexes = {2} }, .referenced = {}, .isRelaxed = false, .expectedMultinomialDistributionTolerance = 0, .expectFailure = false, .minSupportedVersion = TestHalVersion::V1_2 }; return model; } const auto dummy_test_model_corner_case_dim1_axis0_neg_all_inputs_as_internal = TestModelManager::get().add("l2_normalization_axis_corner_case_dim1_axis0_neg_all_inputs_as_internal", get_test_model_corner_case_dim1_axis0_neg_all_inputs_as_internal()); } // namespace generated_tests::l2_normalization_axis