test directory modify mkldnn [fluid_ops] - part

paddle/common/layout.h

@@ -85,6 +85,8 @@ inline DataLayout StringToDataLayout(const std::string& str) {
  return DataLayout::kAnyLayout;
  } else if (s == "MKLDNNLAYOUT") {
  return DataLayout::kMKLDNN;
+ } else if (s == "ONEDNNLAYOUT") {
+ return DataLayout::ONEDNN;
  } else if (s == "SPARSE_COO") {
  return DataLayout::SPARSE_COO;
  } else if (s == "SPARSE_CSR") {

paddle/fluid/framework/op_registry.h

@@ -170,7 +170,7 @@ inline void RegisterKernelClass(const char* op_type,
  std::string library(library_type);
  std::string data_layout = "ANYLAYOUT";
  if (library == "MKLDNN") {
- data_layout = "MKLDNNLAYOUT";
+ data_layout = "ONEDNNLAYOUT";
  }
 #ifdef PADDLE_WITH_CUSTOM_DEVICE
  if (std::is_same<PlaceType, phi::CustomPlace>::value) {

python/paddle/static/quantization/__init__.py

@@ -19,9 +19,11 @@
 )
 from .quant2_int8_onednn_pass import ( # noqa: F401
  Quant2Int8MkldnnPass,
+ Quant2Int8OnednnPass,
 )
 from .quant_int8_onednn_pass import ( # noqa: F401
  QuantInt8MkldnnPass,
+ QuantInt8OnednnPass,
 )
 from .quanter import ( # noqa: F401
  convert,

python/paddle/static/quantization/quant2_int8_onednn_pass.py

@@ -14,13 +14,15 @@
 
 import numpy as np
 
+from paddle.utils import deprecated
+
 from ...base.framework import IrGraph
 from ...framework import _get_paddle_place, core
 
 OpRole = core.op_proto_and_checker_maker.OpRole
 
 
-class Quant2Int8MkldnnPass:
+class Quant2Int8OnednnPass:
  """
  Transform a quant model IrGraph into MKL-DNN supported INT8 IrGraph.
  The pass consists of the following transformations:
@@ -721,3 +723,14 @@ def _quantize_fp32_graph(self, graph):
  graph = self._apply_pass(graph, 'int8_scale_calculation_onednn_pass')
  graph = self._apply_pass(graph, 'params_quantization_onednn_pass')
  return graph
+
+
+class Quant2Int8MkldnnPass(Quant2Int8OnednnPass):
+ @deprecated(
+ since="3.1.0",
+ update_to="paddle.static.quantization.Quant2Int8OnednnPass",
+ level=1,
+ reason="Quant2Int8MkldnnPass will be removed in future",
+ )
+ def __init__(self, *args, **kwargs):
+ super().__init__(*args, **kwargs)

python/paddle/static/quantization/quant_int8_onednn_pass.py

@@ -14,11 +14,13 @@
 
 import numpy as np
 
+from paddle.utils import deprecated
+
 from ...base.framework import IrGraph
 from ...framework import _get_paddle_place
 
 
-class QuantInt8MkldnnPass:
+class QuantInt8OnednnPass:
  """
  Convert QuantizationFreezePass generated IrGraph to MKL-DNN supported INT8
  IrGraph. Following transformations did in this pass:
@@ -48,13 +50,13 @@ def __init__(self, _scope=None, _place=None):
  >>> # The original graph will be rewrite.
  >>> import paddle
  >>> from paddle import static
- >>> from paddle.static.quantization import QuantInt8MkldnnPass
+ >>> from paddle.static.quantization import QuantInt8OnednnPass
  >>> from paddle.framework import IrGraph
  >>> from paddle.framework import core
 
  >>> graph = IrGraph(core.Graph(static.Program().desc), for_test=False)
  >>> place = paddle.CPUPlace()
- >>> onednn_pass = QuantInt8MkldnnPass(static.global_scope(), place)
+ >>> onednn_pass = QuantInt8OnednnPass(static.global_scope(), place)
  >>> onednn_pass.apply(graph)
  """
 
@@ -245,7 +247,7 @@ def _transform_to_quantize_onednn(self, graph, op_node):
  quant_op_node = graph.create_op_node(
  op_type='quantize',
  attrs={
- 'data_format': 'MKLDNNLAYOUT',
+ 'data_format': 'ONEDNNLAYOUT',
  'use_mkldnn': 1,
  'Scale': scale_in,
  'is_negative_input': 1,
@@ -287,3 +289,14 @@ def _remove_unused_var_nodes(self, graph):
  )
  )
  graph.safe_remove_nodes(all_unused_vars)
+
+
+class QuantInt8MkldnnPass(QuantInt8OnednnPass):
+ @deprecated(
+ since="3.1.0",
+ update_to="paddle.static.quantization.QuantInt8OnednnPass",
+ level=1,
+ reason="QuantInt8MkldnnPass will be removed in future",
+ )
+ def __init__(self, *args, **kwargs):
+ super().__init__(*args, **kwargs)

test/cpp/inference/api/config_printer.h

@@ -75,7 +75,7 @@ std::ostream &operator<<(std::ostream &os, const AnalysisConfig &config) {
  << "cpu_num_threads: " << config.cpu_math_library_num_threads() << "\n";
  os << GenSpaces(num_spaces)
  << "use_tensorrt: " << config.tensorrt_engine_enabled() << "\n";
- os << GenSpaces(num_spaces) << "use_mkldnn: " << config.mkldnn_enabled()
+ os << GenSpaces(num_spaces) << "use_onednn: " << config.onednn_enabled()
  << "\n";
  num_spaces--;
  os << GenSpaces(num_spaces) << "}\n";

test/deprecated/cpp/inference/api/analysis_predictor_tester.cc

@@ -335,15 +335,15 @@ TEST(AnalysisPredictor, bf16_pass_strategy) {
  passStrategy.EnableMkldnnBfloat16();
 }
 
-TEST(AnalysisPredictor, mkldnn_fc_pass_strategy) {
+TEST(AnalysisPredictor, onednn_fc_pass_strategy) {
  std::vector<std::string> passes;
  PassStrategy passStrategy(passes);
  passStrategy.DisableOnednnFcPasses();
  ASSERT_EQ(passes.size(), (size_t)0);
 }
 
 #ifdef PADDLE_WITH_DNNL
-TEST(AnalysisPredictor, mkldnn_fc_passes_cpu_pass_strategy) {
+TEST(AnalysisPredictor, onednn_fc_passes_cpu_pass_strategy) {
  CpuPassStrategy cpuPassStrategy;
  cpuPassStrategy.EnableONEDNN();
  const std::vector<std::string> fc_passes_to_erase(
@@ -359,15 +359,15 @@ TEST(AnalysisPredictor, mkldnn_fc_passes_cpu_pass_strategy) {
 #endif
 
 #if defined(PADDLE_WITH_CUDA) || defined(PADDLE_WITH_HIP)
-TEST(AnalysisPredictor, mkldnn_fc_passes_gpu_pass_strategy) {
+TEST(AnalysisPredictor, onednn_fc_passes_gpu_pass_strategy) {
  AnalysisConfig config;
  config.EnableUseGpu(100, 0);
  config.EnableONEDNN();
  config.DisableOnednnFcPasses();
 #ifdef PADDLE_WITH_DNNL
- ASSERT_TRUE(config.mkldnn_fc_passes_disabled());
+ ASSERT_TRUE(config.onednn_fc_passes_disabled());
 #else
- ASSERT_FALSE(config.mkldnn_fc_passes_disabled());
+ ASSERT_FALSE(config.onednn_fc_passes_disabled());
 #endif
 }
 #endif

test/deprecated/cpp/inference/api/analyzer_bert_tester_deprecated.cc

@@ -22,13 +22,13 @@ namespace inference {
 
 using paddle::PaddleTensor;
 
-void profile(bool use_mkldnn = false, bool use_bfloat16 = false);
+void profile(bool use_onednn = false, bool use_bfloat16 = false);
 std::vector<std::vector<paddle::PaddleTensor>> LoadInputData();
-void CompareNativeAndAnalysisWrapper(bool use_mkldnn = false);
+void CompareNativeAndAnalysisWrapper(bool use_onednn = false);
 std::vector<paddle::PaddleTensor> ParseInputStreamToVector(
  const std::string &line);
 
-AnalysisConfig SetConfig(bool use_mkldnn = false, bool use_bfloat16 = false);
+AnalysisConfig SetConfig(bool use_onednn = false, bool use_bfloat16 = false);
 
 template <typename T>
 paddle::PaddleTensor ParseTensor(const std::string &field);
@@ -50,15 +50,15 @@ TEST(Analyzer_bert, profile) {
 }
 
 #ifdef PADDLE_WITH_DNNL
-TEST(Analyzer_bert, profile_mkldnn) {
- auto use_mkldnn = true;
- profile(use_mkldnn);
+TEST(Analyzer_bert, profile_onednn) {
+ auto use_onednn = true;
+ profile(use_onednn);
 }
 
-TEST(Analyzer_bert, profile_mkldnn_bf16) {
- auto use_mkldnn = true;
+TEST(Analyzer_bert, profile_onednn_bf16) {
+ auto use_onednn = true;
  auto use_bfloat16 = true;
- profile(use_mkldnn, use_bfloat16);
+ profile(use_onednn, use_bfloat16);
 }
 #endif
 
@@ -70,8 +70,8 @@ TEST(Analyzer_bert, compare) {
 }
 #ifdef PADDLE_WITH_DNNL
 TEST(Analyzer_bert, compare_mkldnn) {
- auto use_mkldnn = true;
- CompareNativeAndAnalysisWrapper(use_mkldnn);
+ auto use_onednn = true;
+ CompareNativeAndAnalysisWrapper(use_onednn);
 }
 #endif
 
@@ -135,8 +135,8 @@ TEST(Analyzer_bert, transfer_scope_cache) {
  "The size of data cache is not equal to thread number."));
 }
 
-void profile(bool use_mkldnn, bool use_bfloat16) {
- auto config(SetConfig(use_mkldnn, use_bfloat16));
+void profile(bool use_onednn, bool use_bfloat16) {
+ auto config(SetConfig(use_onednn, use_bfloat16));
  std::vector<std::vector<PaddleTensor>> outputs;
  auto inputs = LoadInputData();
  TestPrediction(reinterpret_cast<const PaddlePredictor::Config *>(&config),
@@ -168,8 +168,8 @@ std::vector<std::vector<paddle::PaddleTensor>> LoadInputData() {
  return inputs;
 }
 
-void CompareNativeAndAnalysisWrapper(bool use_mkldnn) {
- auto cfg(SetConfig(use_mkldnn));
+void CompareNativeAndAnalysisWrapper(bool use_onednn) {
+ auto cfg(SetConfig(use_onednn));
  auto inputs = LoadInputData();
  CompareNativeAndAnalysis(
  reinterpret_cast<const PaddlePredictor::Config *>(&cfg), inputs);
@@ -201,12 +201,12 @@ std::vector<paddle::PaddleTensor> ParseInputStreamToVector(
  return tensors;
 }
 
-AnalysisConfig SetConfig(bool use_mkldnn, bool use_bfloat16) {
+AnalysisConfig SetConfig(bool use_onednn, bool use_bfloat16) {
  AnalysisConfig config;
  config.SetModel(FLAGS_infer_model);
  config.DisableFCPadding();
 
- if (use_mkldnn) {
+ if (use_onednn) {
  config.EnableONEDNN();
  }
 

test/deprecated/ir/inference/auto_scan_test.py

@@ -239,7 +239,7 @@ def create_inference_config(
  if use_gpu:
  config.enable_use_gpu(100, 0)
  if not use_mkldnn:
- config.disable_mkldnn()
+ config.disable_onednn()
  if use_xpu:
  config.enable_xpu()
  if passes is not None:
@@ -248,7 +248,7 @@ def create_inference_config(
  return config
 
 
-class MkldnnAutoScanTest(AutoScanTest):
+class OnednnAutoScanTest(AutoScanTest):
  def __init__(self, *args, **kwargs):
  super().__init__(*args, **kwargs)
 
@@ -336,14 +336,14 @@ def run_test(self, quant=False, *args, **kwargs):
 
  def inference_config_str(self, config) -> str:
  dic = {}
- enable_mkldnn = config.mkldnn_enabled()
- dic["use_mkldnn"] = enable_mkldnn
+ enable_onednn = config.onednn_enabled()
+ dic["use_mkldnn"] = enable_onednn
  enable_gpu = config.use_gpu()
  dic["use_gpu"] = enable_gpu
  return str(dic)
 
 
-class PirMkldnnAutoScanTest(MkldnnAutoScanTest):
+class PirOnednnAutoScanTest(OnednnAutoScanTest):
  def __init__(self, *args, **kwargs):
  super().__init__(*args, **kwargs)
 
@@ -572,8 +572,8 @@ def run_test(self, quant=False, prog_configs=None):
 
  def inference_config_str(self, config) -> str:
  dic = {}
- enable_mkldnn = config.mkldnn_enabled()
- dic["use_mkldnn"] = enable_mkldnn
+ enable_onednn = config.onednn_enabled()
+ dic["use_mkldnn"] = enable_onednn
  enable_gpu = config.use_gpu()
  dic['use_gpu'] = enable_gpu
  enable_xpu = config.use_xpu()

test/deprecated/ir/inference/inference_pass_test.py

@@ -38,7 +38,7 @@ def __init__(self, methodName='runTest'):
  self.fetch_list = None
 
  self.enable_mkldnn = False
- self.enable_mkldnn_bfloat16 = False
+ self.enable_onednn_bfloat16 = False
  self.enable_trt = False
  self.enable_tensorrt_varseqlen = False
  self.trt_parameters = None
@@ -143,7 +143,7 @@ def _get_analysis_config(
  self.path + ".pdmodel", self.path + ".pdiparams"
  )
  config.disable_gpu()
- config.disable_mkldnn()
+ config.disable_onednn()
  config.switch_specify_input_names(True)
  config.switch_ir_optim(True)
  config.switch_use_feed_fetch_ops(False)
@@ -179,7 +179,7 @@ def _get_analysis_config(
 
  elif use_mkldnn:
  config.enable_onednn()
- if self.enable_mkldnn_bfloat16:
+ if self.enable_onednn_bfloat16:
  config.enable_onednn_bfloat16()
  return config
 
@@ -285,23 +285,23 @@ def check_output_with_option(
 
  # Check whether the onednn results and the CPU results are the same.
  if (not use_gpu) and self.enable_mkldnn:
- mkldnn_outputs = self._get_inference_outs(
+ onednn_outputs = self._get_inference_outs(
  self._get_analysis_config(
  use_gpu=use_gpu, use_mkldnn=self.enable_mkldnn
  )
  )
 
  self.assertTrue(
- len(paddle_outs) == len(mkldnn_outputs),
+ len(paddle_outs) == len(onednn_outputs),
  "The number of outputs is different between CPU and MKLDNN. ",
  )
 
- if self.enable_mkldnn_bfloat16:
+ if self.enable_onednn_bfloat16:
  atol = 0.01
- for paddle_out, mkldnn_output in zip(paddle_outs, mkldnn_outputs):
+ for paddle_out, onednn_output in zip(paddle_outs, onednn_outputs):
  np.testing.assert_allclose(
  np.array(paddle_out),
- mkldnn_output,
+ onednn_output,
  rtol=1e-05,
  atol=atol,
  err_msg='Output has diff between CPU and MKLDNN. ',