Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit ee7fe25e authored by Xusong Wang's avatar Xusong Wang Committed by Slava Shklyaev
Browse files

Move strided_slice_invalid_output_dims to spec directory. 

Bug: 132155416
Test: 1.2 VTS
Change-Id: I0479b8172c55e5e290f3fc8530a428ac5f54998f
Merged-In: I0479b8172c55e5e290f3fc8530a428ac5f54998f
(cherry picked from commit c99ced16)
parent 42d10ce6

neuralnetworks/1.2/vts/functional/GeneratedTestsV1_2.cpp

+0 −15
Original line number Diff line number Diff line
@@ -44,21 +44,6 @@ std::vector<Request> createRequests(const std::vector<MixedTypedExample>& exampl 
// in frameworks/ml/nn/runtime/tests/generated/

#include "vts/V1_2/all_generated_V1_2_vts_tests.cpp"



// Generated from spec/strided_slice_invalid_output_dims.mod.py.

// TODO(b/132155416): Make this part of all_generated_V1_2_vts_tests.cpp.

namespace strided_slice_invalid_output_dims {

#include "generated/strided_slice_invalid_output_dims.example.cpp"

#include "generated/strided_slice_invalid_output_dims.model.cpp"

}  // namespace strided_slice_invalid_output_dims



// TODO(b/132155416): Make this part of all_generated_V1_2_vts_tests.cpp.

TEST_F(ValidationTest, strided_slice_invalid_output_dims) {

    const Model model = strided_slice_invalid_output_dims::createTestModel();

    const std::vector<Request> requests =

            createRequests(strided_slice_invalid_output_dims::get_examples());

    validateFailure(model, requests);

}



}  // namespace functional

}  // namespace vts

}  // namespace V1_2

neuralnetworks/1.2/vts/functional/generated/strided_slice_invalid_output_dims.example.cpp

deleted100644 → 0
+0 −116
Original line number Diff line number Diff line 
// clang-format off

// Generated file (from: strided_slice_invalid_output_dims.mod.py). Do not edit

std::vector<MixedTypedExample>& get_examples() {

static std::vector<MixedTypedExample> examples = {

// Begin of an example

{

.operands = {

//Input(s)

{ // See tools/test_generator/include/TestHarness.h:MixedTyped

  // int -> Dimensions map

  .operandDimensions = {{0, {2, 3}}},

  // int -> FLOAT32 map

  .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f}}},

  // int -> INT32 map

  .int32Operands = {},

  // int -> QUANT8_ASYMM map

  .quant8AsymmOperands = {},

  // int -> QUANT16_SYMM map

  .quant16SymmOperands = {},

  // int -> FLOAT16 map

  .float16Operands = {},

  // int -> BOOL8 map

  .bool8Operands = {},

  // int -> QUANT8_SYMM_PER_CHANNEL map

  .quant8ChannelOperands = {},

  // int -> QUANT16_ASYMM map

  .quant16AsymmOperands = {},

  // int -> QUANT8_SYMM map

  .quant8SymmOperands = {},

},

//Output(s)

{ // See tools/test_generator/include/TestHarness.h:MixedTyped

  // int -> Dimensions map

  .operandDimensions = {{0, {3}}},

  // int -> FLOAT32 map

  .float32Operands = {{0, {1.0f, 2.0f, 3.0f}}},

  // int -> INT32 map

  .int32Operands = {},

  // int -> QUANT8_ASYMM map

  .quant8AsymmOperands = {},

  // int -> QUANT16_SYMM map

  .quant16SymmOperands = {},

  // int -> FLOAT16 map

  .float16Operands = {},

  // int -> BOOL8 map

  .bool8Operands = {},

  // int -> QUANT8_SYMM_PER_CHANNEL map

  .quant8ChannelOperands = {},

  // int -> QUANT16_ASYMM map

  .quant16AsymmOperands = {},

  // int -> QUANT8_SYMM map

  .quant8SymmOperands = {},

}

},

}, // End of an example

};

return examples;

};



std::vector<MixedTypedExample>& get_examples_dynamic_output_shape() {

static std::vector<MixedTypedExample> examples_dynamic_output_shape = {

// Begin of an example

{

.operands = {

//Input(s)

{ // See tools/test_generator/include/TestHarness.h:MixedTyped

  // int -> Dimensions map

  .operandDimensions = {{0, {2, 3}}},

  // int -> FLOAT32 map

  .float32Operands = {{0, {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f}}},

  // int -> INT32 map

  .int32Operands = {},

  // int -> QUANT8_ASYMM map

  .quant8AsymmOperands = {},

  // int -> QUANT16_SYMM map

  .quant16SymmOperands = {},

  // int -> FLOAT16 map

  .float16Operands = {},

  // int -> BOOL8 map

  .bool8Operands = {},

  // int -> QUANT8_SYMM_PER_CHANNEL map

  .quant8ChannelOperands = {},

  // int -> QUANT16_ASYMM map

  .quant16AsymmOperands = {},

  // int -> QUANT8_SYMM map

  .quant8SymmOperands = {},

},

//Output(s)

{ // See tools/test_generator/include/TestHarness.h:MixedTyped

  // int -> Dimensions map

  .operandDimensions = {{0, {3}}},

  // int -> FLOAT32 map

  .float32Operands = {{0, {1.0f, 2.0f, 3.0f}}},

  // int -> INT32 map

  .int32Operands = {},

  // int -> QUANT8_ASYMM map

  .quant8AsymmOperands = {},

  // int -> QUANT16_SYMM map

  .quant16SymmOperands = {},

  // int -> FLOAT16 map

  .float16Operands = {},

  // int -> BOOL8 map

  .bool8Operands = {},

  // int -> QUANT8_SYMM_PER_CHANNEL map

  .quant8ChannelOperands = {},

  // int -> QUANT16_ASYMM map

  .quant16AsymmOperands = {},

  // int -> QUANT8_SYMM map

  .quant8SymmOperands = {},

}

},

}, // End of an example

};

return examples_dynamic_output_shape;

};

neuralnetworks/1.2/vts/functional/generated/strided_slice_invalid_output_dims.model.cpp

deleted100644 → 0
+0 −216
Original line number Diff line number Diff line 
// clang-format off

// Generated file (from: strided_slice_invalid_output_dims.mod.py). Do not edit

// Create the model

Model createTestModel() {

    const std::vector<Operand> operands = {

        {

            .type = OperandType::TENSOR_FLOAT32,

            .dimensions = {2, 3},

            .numberOfConsumers = 1,

            .scale = 0.0f,

            .zeroPoint = 0,

            .lifetime = OperandLifeTime::MODEL_INPUT,

            .location = {.poolIndex = 0, .offset = 0, .length = 0},

        },

        {

            .type = OperandType::TENSOR_INT32,

            .dimensions = {2},

            .numberOfConsumers = 1,

            .scale = 0.0f,

            .zeroPoint = 0,

            .lifetime = OperandLifeTime::CONSTANT_COPY,

            .location = {.poolIndex = 0, .offset = 0, .length = 8},

        },

        {

            .type = OperandType::TENSOR_INT32,

            .dimensions = {2},

            .numberOfConsumers = 1,

            .scale = 0.0f,

            .zeroPoint = 0,

            .lifetime = OperandLifeTime::CONSTANT_COPY,

            .location = {.poolIndex = 0, .offset = 8, .length = 8},

        },

        {

            .type = OperandType::TENSOR_INT32,

            .dimensions = {2},

            .numberOfConsumers = 1,

            .scale = 0.0f,

            .zeroPoint = 0,

            .lifetime = OperandLifeTime::CONSTANT_COPY,

            .location = {.poolIndex = 0, .offset = 16, .length = 8},

        },

        {

            .type = OperandType::INT32,

            .dimensions = {},

            .numberOfConsumers = 1,

            .scale = 0.0f,

            .zeroPoint = 0,

            .lifetime = OperandLifeTime::CONSTANT_COPY,

            .location = {.poolIndex = 0, .offset = 24, .length = 4},

        },

        {

            .type = OperandType::INT32,

            .dimensions = {},

            .numberOfConsumers = 1,

            .scale = 0.0f,

            .zeroPoint = 0,

            .lifetime = OperandLifeTime::CONSTANT_COPY,

            .location = {.poolIndex = 0, .offset = 28, .length = 4},

        },

        {

            .type = OperandType::INT32,

            .dimensions = {},

            .numberOfConsumers = 1,

            .scale = 0.0f,

            .zeroPoint = 0,

            .lifetime = OperandLifeTime::CONSTANT_COPY,

            .location = {.poolIndex = 0, .offset = 32, .length = 4},

        },

        {

            .type = OperandType::TENSOR_FLOAT32,

            .dimensions = {3},

            .numberOfConsumers = 0,

            .scale = 0.0f,

            .zeroPoint = 0,

            .lifetime = OperandLifeTime::MODEL_OUTPUT,

            .location = {.poolIndex = 0, .offset = 0, .length = 0},

        }

    };



    const std::vector<Operation> operations = {

        {

            .type = OperationType::STRIDED_SLICE,

            .inputs = {0, 1, 2, 3, 4, 5, 6},

            .outputs = {7},

        }

    };



    const std::vector<uint32_t> inputIndexes = {0};

    const std::vector<uint32_t> outputIndexes = {7};

    std::vector<uint8_t> operandValues = {

      0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0

    };

    const std::vector<hidl_memory> pools = {};



    return {

        .operands = operands,

        .operations = operations,

        .inputIndexes = inputIndexes,

        .outputIndexes = outputIndexes,

        .operandValues = operandValues,

        .pools = pools,

    };

}



inline bool is_ignored(int i) {

  static std::set<int> ignore = {};

  return ignore.find(i) != ignore.end();

}



// Create the model

Model createTestModel_dynamic_output_shape() {

    const std::vector<Operand> operands = {

        {

            .type = OperandType::TENSOR_FLOAT32,

            .dimensions = {2, 3},

            .numberOfConsumers = 1,

            .scale = 0.0f,

            .zeroPoint = 0,

            .lifetime = OperandLifeTime::MODEL_INPUT,

            .location = {.poolIndex = 0, .offset = 0, .length = 0},

        },

        {

            .type = OperandType::TENSOR_INT32,

            .dimensions = {2},

            .numberOfConsumers = 1,

            .scale = 0.0f,

            .zeroPoint = 0,

            .lifetime = OperandLifeTime::CONSTANT_COPY,

            .location = {.poolIndex = 0, .offset = 0, .length = 8},

        },

        {

            .type = OperandType::TENSOR_INT32,

            .dimensions = {2},

            .numberOfConsumers = 1,

            .scale = 0.0f,

            .zeroPoint = 0,

            .lifetime = OperandLifeTime::CONSTANT_COPY,

            .location = {.poolIndex = 0, .offset = 8, .length = 8},

        },

        {

            .type = OperandType::TENSOR_INT32,

            .dimensions = {2},

            .numberOfConsumers = 1,

            .scale = 0.0f,

            .zeroPoint = 0,

            .lifetime = OperandLifeTime::CONSTANT_COPY,

            .location = {.poolIndex = 0, .offset = 16, .length = 8},

        },

        {

            .type = OperandType::INT32,

            .dimensions = {},

            .numberOfConsumers = 1,

            .scale = 0.0f,

            .zeroPoint = 0,

            .lifetime = OperandLifeTime::CONSTANT_COPY,

            .location = {.poolIndex = 0, .offset = 24, .length = 4},

        },

        {

            .type = OperandType::INT32,

            .dimensions = {},

            .numberOfConsumers = 1,

            .scale = 0.0f,

            .zeroPoint = 0,

            .lifetime = OperandLifeTime::CONSTANT_COPY,

            .location = {.poolIndex = 0, .offset = 28, .length = 4},

        },

        {

            .type = OperandType::INT32,

            .dimensions = {},

            .numberOfConsumers = 1,

            .scale = 0.0f,

            .zeroPoint = 0,

            .lifetime = OperandLifeTime::CONSTANT_COPY,

            .location = {.poolIndex = 0, .offset = 32, .length = 4},

        },

        {

            .type = OperandType::TENSOR_FLOAT32,

            .dimensions = {0},

            .numberOfConsumers = 0,

            .scale = 0.0f,

            .zeroPoint = 0,

            .lifetime = OperandLifeTime::MODEL_OUTPUT,

            .location = {.poolIndex = 0, .offset = 0, .length = 0},

        }

    };



    const std::vector<Operation> operations = {

        {

            .type = OperationType::STRIDED_SLICE,

            .inputs = {0, 1, 2, 3, 4, 5, 6},

            .outputs = {7},

        }

    };



    const std::vector<uint32_t> inputIndexes = {0};

    const std::vector<uint32_t> outputIndexes = {7};

    std::vector<uint8_t> operandValues = {

      0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0

    };

    const std::vector<hidl_memory> pools = {};



    return {

        .operands = operands,

        .operations = operations,

        .inputIndexes = inputIndexes,

        .outputIndexes = outputIndexes,

        .operandValues = operandValues,

        .pools = pools,

    };

}



inline bool is_ignored_dynamic_output_shape(int i) {

  static std::set<int> ignore = {};

  return ignore.find(i) != ignore.end();

}

neuralnetworks/1.2/vts/functional/spec/strided_slice_invalid_output_dims.mod.py

deleted100644 → 0
+0 −43
Original line number Diff line number Diff line 
#

# Copyright (C) 2019 The Android Open Source Project

#

# Licensed under the Apache License, Version 2.0 (the "License");

# you may not use this file except in compliance with the License.

# You may obtain a copy of the License at

#

#      http://www.apache.org/licenses/LICENSE-2.0

#

# Unless required by applicable law or agreed to in writing, software

# distributed under the License is distributed on an "AS IS" BASIS,

# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

# See the License for the specific language governing permissions and

# limitations under the License.

#



# This test makes sure that executing STRIDED_SLICE results in a failure when

# the output dimensions do not match shrinkAxisMask.

#

# The test generator does not support generating tests resulting in execution

# failure, so the gTest part of this test has been written by hand.

# TODO(b/132155416): Move this under frameworks/ml/nn/runtime/test/specs/V1_2.

#

# Based on strided_slice_float_11.mod.py.



model = Model()

i1 = Input("input", "TENSOR_FLOAT32", "{2, 3}")

begins = Parameter("begins", "TENSOR_INT32", "{2}", [0, 0])

# The value "2" below makes the test invalid. See http://b/79856511#comment2.

ends = Parameter("ends", "TENSOR_INT32", "{2}", [2, 3])

strides = Parameter("strides", "TENSOR_INT32", "{2}", [1, 1])

beginMask = Int32Scalar("beginMask", 0)

endMask = Int32Scalar("endMask", 0)

shrinkAxisMask = Int32Scalar("shrinkAxisMask", 1)



output = Output("output", "TENSOR_FLOAT32", "{3}")



model = model.Operation("STRIDED_SLICE", i1, begins, ends, strides, beginMask, endMask, shrinkAxisMask).To(output)



Example({

    i1: [1, 2, 3, 4, 5, 6],

    output: [1, 2, 3],

})