GitLab

* fix parse_instancenorm to create broadcast and multibroadcast instructions with two dynamic shape arguments instead of 1.  Their make_op() functions don't support dynamic shapes when called with one input.  This caused an error when parsing an ONNX 3duunet model

* Use add_common_op() to create multibroadcast op.

* add verification and parsing test for instance_norm with dynamic input.  Parse test doesn't pass.

* fix for test; still doesn't pass

* another fix for test; still doesn't pass

* work in progress, instance_norm_dyn_batch_test works but instance_norm_test doesn't

* fix onnx instancenorm tests to match parser changes.  Passes all check tests

* Updated comments explaining usage of add_common_op()

* hand-merged conflicts with develop

* fix instance_norm_half_test after merge

* add Onnx test instance_norm_dyn_batch_half_test

* add shape test cases broadcast_1in_dyn_error and multibroadcast_1in_dyn_error_0

By converting to fp32 : fp16 3d-unet model accuracy comes out the same as FP32 accuracy.

By using reduce_sum method on Fp16 : accuracy comes out ~0.9% lower compared to fp32 while keeping entire model in fp16.

Fixes the above behavior
This needs to be changed to allow for setting static shapes with map_dyn_input_dims since you cannot also use map_input_dims

Makes the optimals into a std::set<std::size_t>
Changes shape object functions to handle the opts change
Changes to convolution, flatten, pooling, and convolution in that they no longer calculate the output optimal dimensions. Instead returns empty opts. Will need to change this in the future if we want to support dynamic shapes fully.
Many changes to tests and shape calls with respect to the new optimals

Add dynamic shape support to slice operator.

First draft of this feature doesn't support ops slicing non-fixed, dynamic axes. Resulting shape in such cases is not guaranteed.* Also, onnx parsing doesn't support any arguments other than "axes".

* add dynamic shape support to concat operator.  Includes new op_shape_test and ref_ops_test cases

dyn shape support for Where operator.  Includes shape test, ref_ops test, onx_test. 

* Implement dynamic shapes for scatterND operators.

Dynamic shape support for gathernd op.

Allows migraphx to inline the IF operator when we run into an IF that can be evaluated at compile time, thus avoiding us injecting IF and just inserting the instructions directly.

Dynamic shape support for gather op.

supports upper and lower trilu
not able to support dynamic k values
not able to support negative k values

Adds support for parsing dynamic ONNX gemm bias input C

Extends ONNX Gemm parser to handle dynamic input shapes
Limits ONNX Gemm parsing to 2D input tensors for A and B inputs
As per the ONNX specifications
Changed Gemm ONNX tests to 2D input versions
Add onnx_verify tests for Gemm
Parsing ONNX Gemm links to more than one operator, checking that it produces the correct result

Extends pad operator to handle dynamic input shapes
Only handles computing the shape for adding constant padding to a dynamic shape
- adds the padding to the min, max, and opt values (unless opt is 0, where it keeps it 0)
- does not handle reflect padding with dynamic shapes

Extends parse_matmul.hpp to handle dynamic input shapes
Does not support broadcasting of the outer dimensions for dynamic shapes at this time

Fixes ONNX parsing of convolution to handle dynamic broadcasting of bias input

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

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 

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

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.

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.

* Add in changes for onnx Mod operator

Initial operator for mod implementation and test cases for integer and floating based types.

Need to use fmod from stdlib for floating point types. half_float::half thankfully is specced to the use the existing std::fmod() call when looking at the half.hpp implementation.

fmod_flag should mirror the onnx fmod attribute. Right now using a floating point type without setting that on the user side to true will result in an exception.

Ref ticket #1283