Merge

src/include/migraphx/op/batch_norm_inference.hpp

@@ -24,16 +24,9 @@
 #ifndef MIGRAPHX_GUARD_OPERATORS_BATCH_NORM_HPP
 #define MIGRAPHX_GUARD_OPERATORS_BATCH_NORM_HPP
 
-#include <array>
-#include <migraphx/op/common.hpp>
 #include <migraphx/check_shapes.hpp>
-#include <migraphx/stringutils.hpp>
-#include <migraphx/streamutils.hpp>
-#include <migraphx/literal.hpp>
-#include <migraphx/shape_for_each.hpp>
 #include <migraphx/config.hpp>
 #include <cmath>
-#include <utility>
 
 namespace migraphx {
 inline namespace MIGRAPHX_INLINE_NS {

src/include/migraphx/op/binary.hpp

@@ -26,9 +26,7 @@
 
 #include <migraphx/op/name.hpp>
 #include <migraphx/check_shapes.hpp>
-#include <migraphx/shape_for_each.hpp>
 #include <migraphx/argument.hpp>
-#include <migraphx/stringutils.hpp>
 #include <migraphx/value.hpp>
 
 namespace migraphx {

src/include/migraphx/op/broadcast.hpp

@@ -24,14 +24,9 @@
 #ifndef MIGRAPHX_GUARD_OPERATORS_BROADCAST_HPP
 #define MIGRAPHX_GUARD_OPERATORS_BROADCAST_HPP
 
-#include <array>
 #include <migraphx/check_shapes.hpp>
 #include <migraphx/argument.hpp>
-#include <migraphx/functional.hpp>
 #include <migraphx/config.hpp>
-#include <migraphx/lifetime.hpp>
-#include <cmath>
-#include <utility>
 
 namespace migraphx {
 inline namespace MIGRAPHX_INLINE_NS {

src/include/migraphx/op/capture.hpp

@@ -24,11 +24,8 @@
 #ifndef MIGRAPHX_GUARD_OPERATORS_CAPTURE_HPP
 #define MIGRAPHX_GUARD_OPERATORS_CAPTURE_HPP
 
-#include <array>
 #include <migraphx/check_shapes.hpp>
-#include <migraphx/stringutils.hpp>
-#include <migraphx/streamutils.hpp>
-#include <migraphx/literal.hpp>
+#include <migraphx/argument.hpp>
 #include <migraphx/shape_for_each.hpp>
 #include <migraphx/config.hpp>
 #include <migraphx/context.hpp>

src/include/migraphx/op/clip.hpp

@@ -25,16 +25,12 @@
 #define MIGRAPHX_GUARD_OPERATORS_CLIP_HPP
 
 #include <array>
-#include <migraphx/op/unary.hpp>
 #include <migraphx/check_shapes.hpp>
-#include <migraphx/stringutils.hpp>
-#include <migraphx/streamutils.hpp>
-#include <migraphx/literal.hpp>
+#include <migraphx/argument.hpp>
 #include <migraphx/par_for.hpp>
 #include <migraphx/config.hpp>
+#include <migraphx/value.hpp>
 #include <cmath>
-#include <utility>
-#include <limits>
 
 namespace migraphx {
 inline namespace MIGRAPHX_INLINE_NS {

src/include/migraphx/op/common.hpp

@@ -37,7 +37,9 @@ enum padding_mode_t
 {
     default_, // NOLINT
     same,
-    valid
+    valid,
+    same_lower,
+    same_upper
 };
 
 // The pooling modes must correspond 1-1 to the operators defined for struct parse_pooling.

src/include/migraphx/op/concat.hpp

@@ -36,7 +36,6 @@
 #include <migraphx/op/normalize_attribute.hpp>
 #include <cmath>
 #include <utility>
-#include <migraphx/tune_axis.hpp>
 
 namespace migraphx {
 inline namespace MIGRAPHX_INLINE_NS {

src/include/migraphx/op/contiguous.hpp

@@ -24,15 +24,10 @@
 #ifndef MIGRAPHX_GUARD_OPERATORS_CONTIGUOUS_HPP
 #define MIGRAPHX_GUARD_OPERATORS_CONTIGUOUS_HPP
 
-#include <array>
 #include <migraphx/check_shapes.hpp>
-#include <migraphx/stringutils.hpp>
-#include <migraphx/streamutils.hpp>
-#include <migraphx/literal.hpp>
+#include <migraphx/argument.hpp>
 #include <migraphx/shape_for_each.hpp>
 #include <migraphx/config.hpp>
-#include <cmath>
-#include <utility>
 
 namespace migraphx {
 inline namespace MIGRAPHX_INLINE_NS {

src/include/migraphx/op/convert.hpp

@@ -24,16 +24,9 @@
 #ifndef MIGRAPHX_GUARD_OPERATORS_CONVERT_HPP
 #define MIGRAPHX_GUARD_OPERATORS_CONVERT_HPP
 
-#include <array>
-#include <migraphx/op/unary.hpp>
-#include <migraphx/check_shapes.hpp>
-#include <migraphx/stringutils.hpp>
-#include <migraphx/streamutils.hpp>
-#include <migraphx/literal.hpp>
-#include <migraphx/shape_for_each.hpp>
 #include <migraphx/config.hpp>
+#include <migraphx/op/unary.hpp>
 #include <cmath>
-#include <utility>
 
 namespace migraphx {
 inline namespace MIGRAPHX_INLINE_NS {

src/include/migraphx/op/convolution.hpp

@@ -24,16 +24,10 @@
 #ifndef MIGRAPHX_GUARD_OPERATORS_CONVOLUTION_HPP
 #define MIGRAPHX_GUARD_OPERATORS_CONVOLUTION_HPP
 
-#include <array>
 #include <migraphx/op/common.hpp>
 #include <migraphx/check_shapes.hpp>
-#include <migraphx/stringutils.hpp>
-#include <migraphx/streamutils.hpp>
-#include <migraphx/literal.hpp>
-#include <migraphx/shape_for_each.hpp>
 #include <migraphx/config.hpp>
 #include <migraphx/value.hpp>
-#include <migraphx/op/normalize_attribute.hpp>
 #include <cmath>
 #include <utility>
 
@@ -47,8 +41,9 @@ struct convolution
     std::vector<std::size_t> stride   = {1, 1};
     std::vector<std::size_t> dilation = {1, 1};
 
-    int group                   = 1;
-    padding_mode_t padding_mode = default_;
+    int group                      = 1;
+    padding_mode_t padding_mode    = default_;
+    bool use_dynamic_same_auto_pad = false;
 
     template <class Self, class F>
     static auto reflect(Self& self, F f)
@@ -57,7 +52,8 @@ struct convolution
                     f(self.stride, "stride"),
                     f(self.dilation, "dilation"),
                     f(self.group, "group"),
-                    f(self.padding_mode, "padding_mode"));
+                    f(self.padding_mode, "padding_mode"),
+                    f(self.use_dynamic_same_auto_pad, "use_dynamic_same_auto_pad"));
     }
 
     std::string name() const { return "convolution"; }
@@ -75,43 +71,137 @@ struct convolution
 
     shape normalize_compute_shape(std::vector<shape> inputs) const
     {
-        check_shapes{inputs, *this}.has(2).same_type().same_ndims().min_ndims(3);
+        check_shapes{inputs, *this, true}.has(2).same_type().same_ndims().min_ndims(3);
         check_attribute_size();
-        // dim num of input and attribute should match
-        auto input_size   = inputs[0].lens().size();
-        auto padding_size = padding.size();
+        // num of dims of input and attribute should match
+        const auto input_size   = inputs[0].max_lens().size();
+        const auto padding_size = padding.size();
         if(not(input_size == padding_size / 2 + 2 or input_size == padding_size + 2))
         {
             MIGRAPHX_THROW("CONVOLUTION: input and attribute size mismatch!");
         }
 
-        const shape& input   = inputs.at(0);
-        const shape& weights = inputs.at(1);
-        size_t kdims         = input_size - 2;
-        if(kdims != this->kdims())
+        const shape& x_shape          = inputs.at(0);
+        const shape& w_shape          = inputs.at(1);
+        const size_t num_spatial_dims = input_size - 2;
+        if(num_spatial_dims != this->kdims())
         {
-            MIGRAPHX_THROW("convolution: input k-dims does not match attribute size");
+            MIGRAPHX_THROW("CONVOLUTION: input k-dims does not match attribute size");
         }
 
-        if(input.lens().at(1) != (weights.lens().at(1) * group))
-            MIGRAPHX_THROW("CONVOLUTION: Mismatch channel numbers");
+        if(not x_shape.dynamic() and not w_shape.dynamic() and
+           x_shape.lens().at(1) != (w_shape.lens().at(1) * group))
+            MIGRAPHX_THROW("CONVOLUTION: mismatched channel numbers");
 
-        std::vector<size_t> output_lens{input.lens()[0], weights.lens()[0]};
+        std::vector<op::padding_mode_t> dyn_pad_modes = {op::padding_mode_t::same_upper,
+                                                         op::padding_mode_t::same_lower};
+        if(use_dynamic_same_auto_pad and not contains(dyn_pad_modes, padding_mode))
+        {
+            MIGRAPHX_THROW("CONVOLUTION: use_dynamic_same_auto_pad set with invalid padding mode");
+        }
+
+        if(x_shape.dynamic() or w_shape.dynamic())
+        {
+            return dynamic_compute_shape(x_shape, w_shape);
+        }
+        else
+        {
+            return fixed_compute_shape(x_shape, w_shape);
+        }
+    }
+
+    std::vector<std::size_t> calc_conv_lens(std::vector<std::size_t> x_lens,
+                                            std::vector<std::size_t> w_lens) const
+    {
+        const size_t num_spatial_dims = x_lens.size() - 2;
+        std::vector<size_t> ret       = {};
+        // calculate the output shape of the convolution: ((W - K + 2P) / S) + 1
+        for(size_t i = 0; i < num_spatial_dims; i++)
+        {
+            if(x_lens[i] == 0 or w_lens[i] == 0)
+            {
+                // for handling when a dimension = 0 (opt of dynamic_dimension)
+                ret.push_back(0);
+            }
+            else
+            {
+                auto padding_factor = 2 * padding[i];
+                if(padding.size() == 2 * num_spatial_dims)
+                {
+                    // when padding is {x0_begin, x1_begin, ... x0_end , x1_end, ...}
+                    padding_factor = padding[i] + padding[i + num_spatial_dims];
+                }
+                ret.push_back(std::size_t(std::max<std::ptrdiff_t>(
+                    1,
+                    (x_lens[i + 2] - (1 + dilation[i] * (w_lens[i + 2] - 1)) + padding_factor) /
+                            stride[i] +
+                        1)));
+            }
+        }
+        return ret;
+    }
 
-        for(size_t i = 0; i < kdims; i++)
+    shape dynamic_compute_shape(shape x_shape, shape w_shape) const
+    {
+        std::vector<shape::dynamic_dimension> output_dyn_dims = {};
+
+        auto dynamic_shape_push_back = [&](const shape& input_shape) {
+            if(input_shape.dynamic())
+            {
+                output_dyn_dims.push_back(input_shape.dyn_dims().at(0));
+            }
+            else
+            {
+                auto l = input_shape.lens().at(0);
+                output_dyn_dims.push_back({l, l, 0});
+            }
+        };
+
+        dynamic_shape_push_back(x_shape);
+        dynamic_shape_push_back(w_shape);
+
+        const size_t num_spatial_dims = x_shape.max_lens().size() - 2;
+        if(use_dynamic_same_auto_pad)
         {
-            auto padding_factor = 2 * padding[i];
-            if(padding_size == 2 * kdims)
-                padding_factor = padding[i] + padding[i + kdims];
-            output_lens.push_back(std::size_t(std::max<std::ptrdiff_t>(
-                1,
-                (input.lens()[i + 2] - (1 + dilation[i] * (weights.lens()[i + 2] - 1)) +
-                 padding_factor) /
-                        stride[i] +
-                    1)));
+            for(std::size_t i = 0; i < num_spatial_dims; ++i)
+            {
+                auto ceil_div = [](std::size_t x, std::size_t y) { return (x + y - 1) / y; };
+                auto s        = stride[i];
+                if(x_shape.dynamic())
+                {
+                    auto x = x_shape.dyn_dims()[i + 2];
+                    output_dyn_dims.push_back(shape::dynamic_dimension{
+                        ceil_div(x.min, s), ceil_div(x.max, s), ceil_div(x.opt, s)});
+                }
+                else
+                {
+                    auto od = ceil_div(x_shape.lens()[i + 2], s);
+                    output_dyn_dims.push_back(shape::dynamic_dimension{od, od, 0});
+                }
+            }
         }
+        else
+        {
+            auto min_spatial_dims = calc_conv_lens(x_shape.min_lens(), w_shape.max_lens());
+            auto max_spatial_dims = calc_conv_lens(x_shape.max_lens(), w_shape.min_lens());
+            auto opt_spatial_dims = calc_conv_lens(x_shape.opt_lens(), w_shape.opt_lens());
+            for(size_t i = 0; i < num_spatial_dims; ++i)
+            {
+                output_dyn_dims.push_back(shape::dynamic_dimension{
+                    min_spatial_dims[i], max_spatial_dims[i], opt_spatial_dims[i]});
+            }
+        }
+        return shape{x_shape.type(), output_dyn_dims};
+    }
 
-        return inputs[0].with_lens(output_lens);
+    shape fixed_compute_shape(shape x_shape, shape w_shape) const
+    {
+        std::vector<size_t> output_lens{x_shape.lens()[0], w_shape.lens()[0]};
+        auto spatial_lens = calc_conv_lens(x_shape.lens(), w_shape.lens());
+        std::for_each(spatial_lens.begin(), spatial_lens.end(), [&output_lens](auto x) {
+            output_lens.push_back(x);
+        });
+        return x_shape.with_lens(output_lens);
     }
 
     size_t kdims() const

src/include/migraphx/op/cos.hpp

@@ -24,16 +24,9 @@
 #ifndef MIGRAPHX_GUARD_OPERATORS_COS_HPP
 #define MIGRAPHX_GUARD_OPERATORS_COS_HPP
 
-#include <array>
-#include <migraphx/op/unary.hpp>
-#include <migraphx/check_shapes.hpp>
-#include <migraphx/stringutils.hpp>
-#include <migraphx/streamutils.hpp>
-#include <migraphx/literal.hpp>
-#include <migraphx/shape_for_each.hpp>
 #include <migraphx/config.hpp>
+#include <migraphx/op/unary.hpp>
 #include <cmath>
-#include <utility>
 
 namespace migraphx {
 inline namespace MIGRAPHX_INLINE_NS {

src/include/migraphx/op/cosh.hpp

@@ -24,16 +24,9 @@
 #ifndef MIGRAPHX_GUARD_OPERATORS_COSH_HPP
 #define MIGRAPHX_GUARD_OPERATORS_COSH_HPP
 
-#include <array>
-#include <migraphx/op/unary.hpp>
-#include <migraphx/check_shapes.hpp>
-#include <migraphx/stringutils.hpp>
-#include <migraphx/streamutils.hpp>
-#include <migraphx/literal.hpp>
-#include <migraphx/shape_for_each.hpp>
 #include <migraphx/config.hpp>
+#include <migraphx/op/unary.hpp>
 #include <cmath>
-#include <utility>
 
 namespace migraphx {
 inline namespace MIGRAPHX_INLINE_NS {

src/include/migraphx/op/deconvolution.hpp

@@ -24,16 +24,13 @@
 #ifndef MIGRAPHX_GUARD_OPERATORS_DECONVOLUTION_HPP
 #define MIGRAPHX_GUARD_OPERATORS_DECONVOLUTION_HPP
 
-#include <array>
 #include <migraphx/op/common.hpp>
 #include <migraphx/check_shapes.hpp>
-#include <migraphx/stringutils.hpp>
-#include <migraphx/streamutils.hpp>
-#include <migraphx/literal.hpp>
-#include <migraphx/shape_for_each.hpp>
 #include <migraphx/config.hpp>
-#include <migraphx/dfor.hpp>
+#include <migraphx/value.hpp>
+#include <migraphx/argument.hpp>
 #include <migraphx/par_dfor.hpp>
+#include <migraphx/shape_for_each.hpp>
 #include <cmath>
 #include <utility>
 

src/include/migraphx/op/dequantizelinear.hpp

@@ -24,20 +24,12 @@
 #ifndef MIGRAPHX_GUARD_OPERATORS_DEQUANTIZE_LINEAR_HPP
 #define MIGRAPHX_GUARD_OPERATORS_DEQUANTIZE_LINEAR_HPP
 
-#include <array>
-#include <migraphx/op/common.hpp>
-#include <migraphx/operation.hpp>
 #include <migraphx/check_shapes.hpp>
-#include <migraphx/stringutils.hpp>
-#include <migraphx/streamutils.hpp>
-#include <migraphx/literal.hpp>
 #include <migraphx/config.hpp>
+#include <migraphx/argument.hpp>
 #include <migraphx/par_for.hpp>
 #include <migraphx/value.hpp>
-#include <migraphx/op/normalize_attribute.hpp>
-#include <migraphx/tune_axis.hpp>
 #include <cmath>
-#include <utility>
 
 namespace migraphx {
 inline namespace MIGRAPHX_INLINE_NS {

src/include/migraphx/op/div.hpp

@@ -24,16 +24,8 @@
 #ifndef MIGRAPHX_GUARD_OPERATORS_DIV_HPP
 #define MIGRAPHX_GUARD_OPERATORS_DIV_HPP
 
-#include <array>
-#include <migraphx/op/binary.hpp>
-#include <migraphx/check_shapes.hpp>
-#include <migraphx/stringutils.hpp>
-#include <migraphx/streamutils.hpp>
-#include <migraphx/literal.hpp>
-#include <migraphx/shape_for_each.hpp>
 #include <migraphx/config.hpp>
-#include <cmath>
-#include <utility>
+#include <migraphx/op/binary.hpp>
 
 namespace migraphx {
 inline namespace MIGRAPHX_INLINE_NS {

src/include/migraphx/op/dot.hpp

@@ -24,16 +24,10 @@
 #ifndef MIGRAPHX_GUARD_OPERATORS_DOT_HPP
 #define MIGRAPHX_GUARD_OPERATORS_DOT_HPP
 
-#include <array>
 #include <migraphx/check_shapes.hpp>
-#include <migraphx/stringutils.hpp>
-#include <migraphx/streamutils.hpp>
-#include <migraphx/literal.hpp>
-#include <migraphx/shape_for_each.hpp>
+#include <migraphx/argument.hpp>
 #include <migraphx/config.hpp>
 #include <migraphx/gemm.hpp>
-#include <cmath>
-#include <utility>
 
 namespace migraphx {
 inline namespace MIGRAPHX_INLINE_NS {

src/include/migraphx/op/elu.hpp

@@ -24,15 +24,9 @@
 #ifndef MIGRAPHX_GUARD_OPERATORS_ELU_HPP
 #define MIGRAPHX_GUARD_OPERATORS_ELU_HPP
 
-#include <array>
-#include <migraphx/check_shapes.hpp>
-#include <migraphx/stringutils.hpp>
-#include <migraphx/streamutils.hpp>
-#include <migraphx/literal.hpp>
-#include <migraphx/shape_for_each.hpp>
 #include <migraphx/config.hpp>
+#include <migraphx/op/unary.hpp>
 #include <cmath>
-#include <utility>
 
 namespace migraphx {
 inline namespace MIGRAPHX_INLINE_NS {

src/include/migraphx/op/equal.hpp

@@ -24,11 +24,8 @@
 #ifndef MIGRAPHX_GUARD_OPERATORS_EQUAL_HPP
 #define MIGRAPHX_GUARD_OPERATORS_EQUAL_HPP
 
-#include <migraphx/op/binary.hpp>
-#include <migraphx/operation.hpp>
-#include <migraphx/check_shapes.hpp>
-#include <migraphx/float_equal.hpp>
 #include <migraphx/config.hpp>
+#include <migraphx/op/binary.hpp>
 
 namespace migraphx {
 inline namespace MIGRAPHX_INLINE_NS {

src/include/migraphx/op/exp.hpp

@@ -24,16 +24,9 @@
 #ifndef MIGRAPHX_GUARD_OPERATORS_EXP_HPP
 #define MIGRAPHX_GUARD_OPERATORS_EXP_HPP
 
-#include <array>
-#include <migraphx/op/unary.hpp>
-#include <migraphx/check_shapes.hpp>
-#include <migraphx/stringutils.hpp>
-#include <migraphx/streamutils.hpp>
-#include <migraphx/literal.hpp>
-#include <migraphx/shape_for_each.hpp>
 #include <migraphx/config.hpp>
+#include <migraphx/op/unary.hpp>
 #include <cmath>
-#include <utility>
 
 namespace migraphx {
 inline namespace MIGRAPHX_INLINE_NS {

src/include/migraphx/op/flatten.hpp

@@ -24,18 +24,11 @@
 #ifndef MIGRAPHX_GUARD_OPERATORS_FLATTEN_HPP
 #define MIGRAPHX_GUARD_OPERATORS_FLATTEN_HPP
 
-#include <array>
 #include <migraphx/check_shapes.hpp>
-#include <migraphx/stringutils.hpp>
-#include <migraphx/streamutils.hpp>
-#include <migraphx/literal.hpp>
-#include <migraphx/shape_for_each.hpp>
+#include <migraphx/argument.hpp>
 #include <migraphx/config.hpp>
 #include <migraphx/value.hpp>
 #include <migraphx/op/normalize_attribute.hpp>
-#include <migraphx/lifetime.hpp>
-#include <cmath>
-#include <utility>
 
 namespace migraphx {
 inline namespace MIGRAPHX_INLINE_NS {