Enable upsample_bilinear2d to support the scale factor is vector

Author: EikanWang

scripts/cpu/gen-dense-cpu-ops.py

@@ -95,7 +95,9 @@
     'aten::upsample_linear1d(Tensor self, int[1] output_size, bool align_corners, float? scales=None) -> Tensor',
     'aten::upsample_linear1d_backward(Tensor grad_output, int[1] output_size, int[3] input_size, bool align_corners, float? scales=None) -> Tensor',
     'aten::upsample_bilinear2d(Tensor self, int[2] output_size, bool align_corners, float? scales_h=None, float? scales_w=None) -> Tensor',
+    'aten::upsample_bilinear2d.vec(Tensor input, int[]? output_size, bool align_corners, float[]? scale_factors) -> Tensor',
     'aten::upsample_bilinear2d_backward(Tensor grad_output, int[2] output_size, int[4] input_size, bool align_corners, float? scales_h=None, float? scales_w=None) -> Tensor',
+    'aten::upsample_bilinear2d_backward.vec(Tensor grad_output, int[]? output_size, int[] input_size, bool align_corners, float[]? scale_factors) -> Tensor',
     'aten::upsample_trilinear3d(Tensor self, int[3] output_size, bool align_corners, float? scales_d=None, float? scales_h=None, float? scales_w=None) -> Tensor',
     'aten::upsample_trilinear3d_backward(Tensor grad_output, int[3] output_size, int[5] input_size, bool align_corners, float? scales_d=None, float? scales_h=None, float? scales_w=None) -> Tensor',
     'aten::unsqueeze(Tensor(a) self, int dim) -> Tensor(a)',
@@ -578,7 +580,7 @@ def is_conv_overrideable_func(fname):
 
             # Gen OP Name
             code += '#if defined(IPEX_DISP_OP)\n'
-            code += '  printf("{}::{}\\n");\n'.format(_IPEX_OP_FUNC_NS, cpp_sig.def_name)
+            code += '  printf("{}::{}\\n");\n'.format(_IPEX_OP_FUNC_NS, new_cpp_func_name)
             code += '#endif\n'
 
             # Gen profile info
@@ -587,7 +589,7 @@ def is_conv_overrideable_func(fname):
                 if param.core_type in ['Tensor', 'Scalar']:
                     profiler_inputs.append(param.name)
             code += '#if defined(IPEX_PROFILE_OP)\n'
-            code += '  RECORD_FUNCTION("{ns}::{name}", std::vector<c10::IValue>({{}}));\n'.format(ns=_IPEX_OP_FUNC_NS, name=cpp_sig.def_name)
+            code += '  RECORD_FUNCTION("{ns}::{name}", std::vector<c10::IValue>({{}}));\n'.format(ns=_IPEX_OP_FUNC_NS, name=new_cpp_func_name)
             code += '#endif\n'
 
             if is_conv_overrideable_func(cpp_sig.def_name):

tests/cpu/test_lazy_reorder.py

@@ -1966,6 +1966,17 @@ def test_upsample_bilinear2d_scale_factor(self):
             y_dpcpp.sum().backward()
             self.assertEqual(x_cpu.grad, x_dpcpp.grad)
 
+        with AutoDNNL(True):
+            x = torch.randn(2, 2, 4, 4)
+            x_cpu = x.clone().requires_grad_()
+            x_dpcpp = x.clone().to(device=device).requires_grad_()
+            y_cpu = F.interpolate(x_cpu, scale_factor = [2, 3], mode='bilinear', align_corners=False, recompute_scale_factor=False)
+            y_dpcpp = F.interpolate(x_dpcpp, scale_factor = [2, 3], mode='bilinear', align_corners=False, recompute_scale_factor=False)
+            self.assertEqual(y_cpu, y_dpcpp)
+            y_cpu.sum().backward()
+            y_dpcpp.sum().backward()
+            self.assertEqual(x_cpu.grad, x_dpcpp.grad)
+
     def test_upsample_bilinear2d_size(self):
         rand_seed = int(get_rand_seed())
         print("{} rand sed: {}".format(sys._getframe().f_code.co_name, rand_seed))

torch_ipex/csrc/cpu/DevOPs.cpp

@@ -2708,6 +2708,17 @@ at::Tensor AtenIpexCPUDev::dil_upsample_linear1d_backward(const at::Tensor & gra
   return dbl::upsample::dil_upsample_backward(grad_output, input_size, dil::algorithm::resampling_linear, scales);
 }
 
+at::Tensor AtenIpexCPUDev::dil_upsample_bilinear2d(const at::Tensor & self,  c10::optional<at::IntArrayRef> output_size, bool align_corners, c10::optional<c10::ArrayRef<double>> scale_factors) {
+  DEBUG("AtenIpexCPUDev::dil_upsample_bilinear2d_vec\n");
+  auto scale_h = c10::optional<double>(1.0);
+  auto scale_w = c10::optional<double>(1.0);
+  if (scale_factors.has_value()) {
+    scale_h = c10::optional<double>(scale_factors->at(0));
+    scale_w = c10::optional<double>(scale_factors->at(1));
+  }
+  return dbl::upsample::dil_upsample(self, output_size.value(), dil::algorithm::resampling_linear, scale_h, scale_w);
+}
+
 at::Tensor AtenIpexCPUDev::dil_upsample_bilinear2d(const at::Tensor & self, at::IntArrayRef output_size, bool align_corners, c10::optional<double> scales_h, c10::optional<double> scales_w) {
   DEBUG("AtenIpexCPUDev::dil_upsample_bilinear2d\n");
   IPEX_CHECK(align_corners == false, "dil_upsample_bilinear2d not support align_corners mode yet");
@@ -2722,6 +2733,19 @@ at::Tensor AtenIpexCPUDev::dil_upsample_bilinear2d_backward(const at::Tensor & g
   return dbl::upsample::dil_upsample_backward(grad_output, input_size, dil::algorithm::resampling_linear, scales_h, scales_w);
 }
 
+at::Tensor AtenIpexCPUDev::dil_upsample_bilinear2d_backward(const at::Tensor & grad_output, c10::optional<at::IntArrayRef> output_size, at::IntArrayRef input_size, bool align_corners, c10::optional<c10::ArrayRef<double>> scale_factors) {
+  DEBUG("AtenIpexCPUDev::dil_upsample_bilinear2d_backward_vec\n");
+  IPEX_CHECK(align_corners == false, "dil_upsample_bilinear2d_backward_vec not support align_corners mode yet");
+  CHECK_DNNL_OP_PRE_COND(grad_output);
+  auto scales_h = c10::optional<double>(1.0);
+  auto scales_w = c10::optional<double>(1.0);
+  if (scale_factors.has_value()) {
+    scales_h = c10::optional<double>(scale_factors->at(0));
+    scales_w = c10::optional<double>(scale_factors->at(1));
+  }
+  return dbl::upsample::dil_upsample_backward(grad_output, input_size, dil::algorithm::resampling_linear, scales_h, scales_w);
+}
+
 at::Tensor AtenIpexCPUDev::dil_upsample_trilinear3d(const at::Tensor & self, at::IntArrayRef output_size, bool align_corners, c10::optional<double> scales_d, c10::optional<double> scales_h, c10::optional<double> scales_w) {
   DEBUG("AtenIpexCPUDev::dil_upsample_trilinear3d\n");
   IPEX_CHECK(align_corners == false, "dil_upsample_trilinear3d not support align_corners mode yet");

torch_ipex/csrc/cpu/DevOPs.h

@@ -104,8 +104,10 @@ class AtenIpexCPUDev {
   static at::Tensor dil_upsample_nearest3d_backward(const at::Tensor & grad_output, at::IntArrayRef output_size, at::IntArrayRef input_size, c10::optional<double> scales_d, c10::optional<double> scales_h, c10::optional<double> scales_w);
   static at::Tensor dil_upsample_linear1d(const at::Tensor & self, at::IntArrayRef output_size, bool align_corners, c10::optional<double> scales);
   static at::Tensor dil_upsample_linear1d_backward(const at::Tensor & grad_output, at::IntArrayRef output_size, at::IntArrayRef input_size, bool align_corners, c10::optional<double> scales);
+  static at::Tensor dil_upsample_bilinear2d(const at::Tensor & self, c10::optional<at::IntArrayRef> output_size, bool align_corners, c10::optional<c10::ArrayRef<double>> scale_factors);
   static at::Tensor dil_upsample_bilinear2d(const at::Tensor & self, at::IntArrayRef output_size, bool align_corners, c10::optional<double> scales_h, c10::optional<double> scales_w);
   static at::Tensor dil_upsample_bilinear2d_backward(const at::Tensor & grad_output, at::IntArrayRef output_size, at::IntArrayRef input_size, bool align_corners, c10::optional<double> scales_h, c10::optional<double> scales_w);
+  static at::Tensor dil_upsample_bilinear2d_backward(const at::Tensor & grad_output, c10::optional<at::IntArrayRef> output_size, at::IntArrayRef input_size, bool align_corners, c10::optional<c10::ArrayRef<double>> scale_factors);
   static at::Tensor dil_upsample_trilinear3d(const at::Tensor & self, at::IntArrayRef output_size, bool align_corners, c10::optional<double> scales_d, c10::optional<double> scales_h, c10::optional<double> scales_w);
   static at::Tensor dil_upsample_trilinear3d_backward(const at::Tensor & grad_output, at::IntArrayRef output_size, at::IntArrayRef input_size, bool align_corners, c10::optional<double> scales_d, c10::optional<double> scales_h, c10::optional<double> scales_w);
   static at::Tensor dil_unsqueeze(const at::Tensor& self, int64_t dim);