GitLab

Implements dynamic shapes in reduce_op and all its child operator classes (reduce_max etc.)

No major changes required, use dyn_output and pass dynamic shape when calling compute_shape()
Adds dynamic shape tests

Changes flatten's compute_shape() to handle dynamic shapes
Calculates the flattened shape with the min, max, and opt

Extends the Argmax operator to handle dynamic input shapes.
Only shape function changes

Extends unsqueeze and squeeze to work for dynamic input shapes
Does not handle the steps parameter
Adds some additional negative axes shape tests

Extends the pooling operators for dynamic shape inputs

AveragePooling
GlobalAveragePooling
MaxPooling
GlobalMaxPooling
LpNormPooling
GlobalLpNormPooling
y.github.com>

Extends ref transpose operator for dynamic shapes
Make dynamic tests more consistent naming

Updated Multibroadcast op to have a two input version for dynamic shapes
Current dynamic shape broadcasting logic
dynamic_dimensions must be the same or one of them is {1, 1, 0} or {1, 1, 1}
Works for dyn-dyn, dyn-static, and static-static shape combinations
Changed common.cpp for multibroadcasting for binary ops with dynamic shapes
Extended binary.hpp for dynamic shapes to test the new common.cpp stuff

Just grab the last output from the non empty branch and use the identity
operator to get the proper shape for the output branch. In the case of
an empty branch (empty tensor, of some type) this tends to mean "Do nothing"
so we're folding the output of the other flow branch here, and thus if somehow,
we do reach this at eval, should throw an error signalling either one of two things

1. Onnx model is invalid
2. The model has run into an error condition with its control flow.

Since IF is an odd operator that can adjust axes, and other operators in a data driven
fashion, this would serve as a check at compile and or/runtime.

Change things in the test cases so that we're not just replicating what
the code does but use add_instruction to dictate what we should expect
for the output of fixing empty const cases.

Had to also switch an insert to add of a literal in the empty case to achieve
this in parse_if as well.

Moved the return instructions to the end of each subgraph to also fix readability
of each test.

Default to smaller dimension with trailing 1 case instead of unsqueezing to
the larger dimension.

More analysis on other networks concludes that when putting in two operands to
and IF block, the output should take the smaller of the shapes instead of the larger

Modified tests in onnx_test.cpp to parse to the correct output as well.

Newer split moves the split attribute to an input. In this case we check the
number of input args then.

Upgraded Dockerfiles and fixed tidy issues to make Ubuntu 20.04 and ROCm 5.3.0 the default 

- Added cases to handle error cases of invalid splits for split-11 and split-13
- should solve issue with code coverage.

Newer split moves the split attribute to an input. In this case we check the
number of input args then.

This changes allows us to move the accumulte check to outside each conditional branch
Added more debug on this as well to show more details on this failure mode.

Adds an additional test case using a generated split-13 operator styled
test.

- Initial fix to handle scalars on input for empty constant values
- Using scalar, multibroadcast, contiguous
- Fixed appropriate unit tests for simple single output constants
- Added unit tests for multi if outputs.

- TODO - multibroadcast to handle scalar so we don't use scalar

Adding test to validate what a "valid" multi input should look like and
that we correctly handle trailing 1s and correctly sized outputs.

Generated and added the two tests from gen_onnx.py with matching test
in onnx_test.cpp

-if_then_else_multi_output_shapes_test.onnx
-if_then_else_multi_output_shapes_test2.onnx

Refactor dynamic compute
- add a compute_output_shape object that implicitly converts to a new dyn_output or shape object
- dyn_output object can handle computing the static output shape of an operator given the input arguments shapes
  change an operator's compute function to argument compute(const dyn_output& dyn_out, std::vector<argument> args) to 
  use dyn_output object

Dynamic ref unary functions
-  Included these changes to have an example of the refactored dynamic compute being used
-  Changes to unary base class to handle dynamic shapes
-  Changed elu and leaky_relu to use unary base class and pointwise JIT

outline seems to be bugged, and going to be depreciated, thus switching to
creating a new literal with the proper shape for the empty output branch.

This test should error out as, having different output shapes for each
branch with one non empty is invalid.

Changes to gen_onnx.py as well as generated onnx file provided

Add the testcase and onnx file generated to handle the case of two output
shapes that vary in rank by one, with a trailing 1 but sub lengths are not equivalent

This should be flagged as an error always for static inputs

- added changes to gen_onnx.py for different type, shape, and incompatible lens
- added test cases that should except in onnx_test.cpp

- gen_onnx.py changes for onnx output of empty const input branches (seen in resnext50)
- updated onnx_test.cpp to validate parsing of input.
- new onnx files generated from onnx tests

- Handle checks for each IF output
- add const to inputs of all_but_last_dims_equal
- add std::equal instead of using equal
- Use .back() for vectors in getting last value
- Use input().front() instead of prev(prev()) when replacing the last value.

Allows for rank 2 tensors into batchnorm.  Specifically when spatial dimensions are all 1 and removed

Removes use_dynamic_same_auto_pad
Change padding_mode to be used for dynamic padding
Move compute_padded_shape to pad_calc.cpp as it will be used in other dynamic padding cases
Fix same_lower compute_padded_shape bug and add a test.

Fixes test which verifies how we interpret vectors with trailing ones, between input branches to
an IF module block.

Update test for new generated onnx file, as well as using unsqueeze output
for when we parse in a network with mismatched shapes with a trailing 1

- Gets past to the split section of the resnext model
- adding outline seems to solve if issues but verify calls broken
- Referencing wrong element now instead of output of correct if block?
- Need to determine proper output through verify tests.
- Modified protobuf to handle case of extra 1 to "vectorize" scalar
- Modified verify/tests to get things to "work", may need to be revised further.

- Update if_then/else_empty test protobuff and cases
- Need to update rand() vector used
- Make y empty instead of x for if_else_empty_test.onnx
- Regenerate protobufs with updates
- Add changes to handle empty/scalar input branch size to if operator.
- Add case where if both branches empty throw an error.
- Update verify tests with gold vectors and new shapes for empty input vec
  which we handle like a scalar before broadcasting

- Verification tests that test each then/else branches for parsed IF operator
- Testing empty shape tensors for one branch -> output must be the other branch's shape
- Testing trailing 1 shape for one branch -> output must be union of both inputs

Current issue with IF operator is that we can't handle training vectors that match
in size correclty while also running into issues with empty inputs for one of the
branches for size/type checks.

Rewrites the BatchNormalization ONNX operator into other MIGX operators
- Added handling of 1D input tensor case (edge case in ONNX spec)
Removes the spatial and per_activation functionality (not in the ONNX spec)
- Did not remove the batch_norm_inference related code as the TensorFlow parser still uses it
- Can remove that code when the TF version is updated

* Remove unused headers

Has NMS op output a dynamic shape (ONNX spec behavior)
Allows for dynamic input shape to NMS op

* Imply type of literal returned based on input protobuff for zero element constant values.

This saves us the default behavior as the onnx parsing assumes that every zero value is float. This way we're still grabbing relevant type information from the protobuff instead and wont fail our data type checks for if them/else blocks from onnx

* Revert "Imply type of literal returned based on input protobuff for zero element constant values."

This reverts commit 390bb853

.

* Add  test case to parse in empty constant int64 proto buffer

I think the previous test case was aliasing an issue where we default to float but need to actually read in int64 instead of int32

* fixup! Add  test case to parse in empty constant int64 proto buffer

* Add test for non empty int64 scalar

Add one item in the np array to use for the constant we're parsing in.

* Draft partial fix

* Fix test failures from previous change to read in protobuf data types correctly for empty constants.

Instead of assuming things are empty and thus we default to float, reading in the correct types broke some assumptions code was using for an empty literal.

* Fix formatting and naming

* Fix naming with var in constant_one_val_int64_test
Co-authored-by: charlie <charlie.lin@amd.com>
Co-authored-by: kahmed10 <15948690+kahmed10@users.noreply.github.com>

* Dynamic shape handling in shape object

* rewrite empty lens multibroadcast test

* Shape class changes to handle dynamic
* More throw errors for functions that don't make sense for dynamic shape
* Print output changes
* Serialization changes

* Fixing serialization errors

* Remove const on dyn_dim copy getters

* Dynamic shape tests

* Fix serialize errors

* Add dyn_data struct to avoid ambiguous constructor

* Tidy fix: emplace_back() over for loop

* Tidy fix: use move

* Use std::initializer_list in constructor
Reverts the dyn_data struct change
Should get around the ambiguous braced initialization list error

* avoid typedef

* element_space, min,max,opt _lens change

* formatting

* Comments fix

* dynamic bytes() test

* Seralize and reflect changes

* formatting

* Test the dynamic lens functions

* progress

* Formatting

* Dynamic conv draft progress

* Add operator<< tests for coverage

* Coverage update

* Add to conv dynamic batch test

* Dynamic image size test

* Dynamic weight handling

* Dyn image shape test change, fix dyn weight cond

* Comment update

* Dynamic weights shape test and fix

* Use ternary operator

* Tidy fixes

* Handle dynamic graph input shapes in ONNX parser

* Formatting

* Handle dynamic shape for convolution

* formatting

* cppcheck fixes

* Add onnx test files

* Fix typo

* Disable auto_pad for dynamic input shape

* check_shapes object checks for allowing dynamic shapes

* Fix any_of

* Change to maintain const objectness

* Formatting

* Check shapes allow dynamic

* Refactor compute_shape() call into op.compute()
Allows for per operator differences with handling dynamic shape
Fix operation.hpp change to use the generator

* Comment fix

* Refactor normalize_attributes() calls to use max_lens()

* Comment addition

* Update other normalize_attributes() calls

* Change to using constructor and add tests

* Use const member function

* Add more dynamic shape support

* Add tests for error code coverage

* Fix opt shape bug and add shape tests

* capture all by ref

* Fix typo with img shape calculation

* Add more tests

* dynamic auto pad attempt
Linker error with pad_calc.cpp

* Fix parse dyn auto_pad
Should only need to use dynamic auto pad when the image shape or kernel
shape are dynamic. For a dynamic batch size, the auto pad calculation is
the same.

* Fix linking error

* Fix auto_pad bug
Fixed input tensor with auto_pad setting on

* auto_pad onnx tests

* Fix auto_pad calculation, evaluate in ref_conv
add ref_ops tests

* Add shape tests, fix bugs

* Refactor first two output dynamic len calculation

* Conv MLIR test update

* i64 MLIR test fix

* Fix MLIR test typo
Co-authored-by: Chris Austen <causten@users.noreply.github.com>

instancenorm parser always creates literal of type float which would fail in type check while creating binary ops if model is fp16.