hide dil from frontend and reuse attr args instead of fuse_relu

Author: zhuhaozhe

intel_pytorch_extension_py/ops/__init__.py

@@ -4,5 +4,5 @@
 from .pooling import *
 from .reshape import *
 from .mlp import * 
-from .dil_linear_relu import *
+from .linear_fuse_relu import *
 

intel_pytorch_extension_py/ops/dil_linear_relu.py renamed to intel_pytorch_extension_py/ops/linear_fuse_relu.py

@@ -6,7 +6,7 @@
 import math
 import _torch_ipex as core
 
-class dilLinearFuseReluFC(Function):
+class LinearFuseReluFC(Function):
     @staticmethod
     def forward(ctx, input, weight, bias):
         output = core.linear_fuse_relu(input, weight, bias)
@@ -25,13 +25,13 @@ def backward(ctx, grad_output):
         grad_input, grad_weight, grad_bias = core.linear_backward(input, grad_output, weight, output_mask)
         return (grad_input, grad_weight, grad_bias)
 
-class dilLinearFuseRelu(nn.Module):
+class LinearFuseRelu(nn.Module):
     r"""DNNL Linear module for using relu fused DNNL kernel"""
 
     __constants__ = ['bias']
 
     def __init__(self, in_features, out_features, bias=True):
-        super(dilLinearFuseRelu, self).__init__()
+        super(LinearFuseRelu, self).__init__()
         self.in_features = in_features
         self.out_features = out_features
         self.weight = Parameter(torch.Tensor(out_features, in_features))
@@ -50,6 +50,6 @@ def reset_parameters(self):
 
     def forward(self, input):
         # print(self.weight.shape)
-        output = dilLinearFuseReluFC.apply(input, self.weight, self.bias)
+        output = LinearFuseReluFC.apply(input, self.weight, self.bias)
         return output
 

torch_ipex/csrc/cpu/DevOPs.cpp

@@ -568,9 +568,17 @@ at::Tensor AtenIpexCPUDev::dil_linear_fuse_relu(
   if (bias.has_value()) {
     at::Tensor bias_vec = bias.value();
     const dil::tensor b = dbl::comm::try_gen_dil_tensor(bias_vec);
-    dil::inner_product_forward::compute(x, w, b, y, /*fuse_relu=*/true);
+    dil::inner_product_forward::compute(x, w, b, y,
+                                        /*src_scales=*/dil::scale_t(),
+                                        /*weight_scales=*/dil::scale_t(),
+                                        /*dst_scales=*/dil::scale_t(),
+                                        /*attr*/dil::attr_t::fuse_relu());
   } else {
-    dil::inner_product_forward::compute(x, w, y, /*fuse_relu=*/true);
+    dil::inner_product_forward::compute(x, w, y,
+                                        /*src_scales=*/dil::scale_t(),
+                                        /*weight_scales=*/dil::scale_t(),
+                                        /*dst_scales=*/dil::scale_t(),
+                                        /*attr*/dil::attr_t::fuse_relu());
   }
 
   auto input_size = self.sizes();

torch_ipex/csrc/cpu/dil/dil/operators/inner_product.hpp

@@ -11,23 +11,21 @@ struct inner_product_forward : public dnnl::inner_product_forward {
                       const tensor& weights,
                       const tensor& bias,
                       tensor& dst,
-                      const bool fuse_relu = false,
                       const scale_t& src_scales = scale_t(),
                       const scale_t& weights_scales = scale_t(),
                       const scale_t& dst_scales = scale_t(),
                       const attr_t& attr = attr_t(),
                       const prop_kind aprop_kind = prop_kind::forward,
                       const lowp_kind alowp_kind = u8s8,
                       const engine& aengine = engine::cpu_engine()) {
-    compute_impl</*with_bias=*/true>(src, weights, bias, dst, fuse_relu, src_scales,
+    compute_impl</*with_bias=*/true>(src, weights, bias, dst, src_scales,
                                      weights_scales, dst_scales, attr,
                                      aprop_kind, alowp_kind, aengine);
   }
 
   static void compute(const tensor& src,
                       const tensor& weights,
                       tensor& dst,
-                      const bool fuse_relu = false,
                       const scale_t& src_scales = scale_t(),
                       const scale_t& weights_scales = scale_t(),
                       const scale_t& dst_scales = scale_t(),
@@ -36,7 +34,7 @@ struct inner_product_forward : public dnnl::inner_product_forward {
                       const lowp_kind alowp_kind = u8s8,
                       const engine& aengine = engine::cpu_engine()) {
     static tensor dummy_bias;
-    compute_impl</*with_bias=*/false>(src, weights, dummy_bias, dst, fuse_relu, src_scales,
+    compute_impl</*with_bias=*/false>(src, weights, dummy_bias, dst, src_scales,
                                       weights_scales, dst_scales, attr,
                                       aprop_kind, alowp_kind, aengine);
   }
@@ -71,7 +69,6 @@ struct inner_product_forward : public dnnl::inner_product_forward {
                            const tensor& weights,
                            const tensor& bias,
                            tensor& dst,
-                           const bool fuse_relu,
                            const scale_t& src_scales,
                            const scale_t& weights_scales,
                            const scale_t& dst_scales,
@@ -87,7 +84,7 @@ struct inner_product_forward : public dnnl::inner_product_forward {
       new_dims[0] = src.get_dim(0);
       src_.reshape(new_dims);
     }
-    compute_impl_<with_bias>(src_, weights, bias, dst, fuse_relu, src_scales,
+    compute_impl_<with_bias>(src_, weights, bias, dst, src_scales,
                              weights_scales, dst_scales, attr, aprop_kind,
                              alowp_kind, aengine);
   }
@@ -97,7 +94,6 @@ struct inner_product_forward : public dnnl::inner_product_forward {
                             const tensor& weights,
                             const tensor& bias,
                             tensor& dst,
-                            const bool fuse_relu,
                             const scale_t& src_scales,
                             const scale_t& weights_scales,
                             const scale_t& dst_scales,
@@ -167,7 +163,7 @@ struct inner_product_forward : public dnnl::inner_product_forward {
         }
       }
     } else {
-      op_attr = fuse_relu ? attr_t::fuse_relu() : attr;
+      op_attr =  attr;
       src_desc = {src.get_dims(), data_type::f32, format_tag::any};
       if (src.has_scale()) {
         auto src_scale = src.get_scale();