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.

Hand verified results before running test using random data generated from
the new protobuf files for this.

Everything is correctly functionally within tolerances.

Had to readjust input sizes to that of the .onnx file as one input is deliberately
made smaller (without the trailing 1) for theses tests to test the case correctly

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

Inverted logic when I wrote generated statements for these. Regenerated files

- 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.

This seemed to be missing, just leveraging the existing protobuf made
to test parsing of if_then_test.onnx for this and using the tensor of all
ones to default to an ADD operation to ensure cond =1 is being handled and parsed
in correctly.

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