Zq/add specified autocompare

.github/workflows/main.yml

@@ -353,21 +353,6 @@ jobs:
           source scripts/ci/ascend/ci_ascend_env.sh
           bash scripts/ci/ascend/ci_ascend_script.sh build_dipu \
           || ( cd ${DEEPLINK_PATH}/${GITHUB_RUN_NUMBER}/ && rm -rf ${GITHUB_JOB} && exit 1 )
-
-  Build-Ascend-910b-with-autocompare:
-    name: Build-dipu-ascend-910b-with-autocompare
-    needs: [Build-PyTorch-For-Ascend-910b]
-    runs-on: tps-ascend-ci-910b
-    steps:
-      - name: Build dipu
-        run: |
-          set -ex
-          export USE_COVERAGE=ON
-          export USE_AUTOCOMPARE=ON
-          cd ${DEEPLINK_PATH}/${GITHUB_RUN_NUMBER}/ && rm -rf ${GITHUB_JOB} && cp -R source ${GITHUB_JOB}  && cd ${GITHUB_JOB}/dipu
-          source scripts/ci/ascend/ci_ascend_env.sh
-          bash scripts/ci/ascend/ci_ascend_script.sh build_dipu \
-          || ( cd ${DEEPLINK_PATH}/${GITHUB_RUN_NUMBER}/ && rm -rf ${GITHUB_JOB} && exit 1 )
 
   Test-Ascend-910b:
     name: Test-dipu-ascend-910b

dipu/QuickStart.md

@@ -158,9 +158,10 @@ sh ./tests/python/run_tests.sh
 
 ### 算子库拓展功能
 
-#### 算子 Fallback
+#### 算子Fallback功能
 
-Fallback 给定算子：
+Fallback指的是使用算子的CPU实现，而非设备实现。  
+Fallback给定算子：
 
 ```bash
 export DIPU_FORCE_FALLBACK_OPS_LIST=add.out,conv2d
@@ -181,20 +182,12 @@ export DIPU_FORCE_FALLBACK_OPS_LIST='.*'
 python -c "import torch_dipu"
 ```
 
-#### 算子精度自动对比功能介绍
+#### 算子精度自动对比功能
 
-由于该功能默认不开启，使用该功能时需要打开该功能并重新编译DIPU。
-
-可以通过设置环境变量USE_AUTOCOMPARE=ON，来开启该功能，然后需要重新编译DIPU。
-
-```shell
-export USE_AUTOCOMPARE=ON
-```
-
-以上方法是对所有算子开启自动精度对比。如果只需要对特定算子做精度对比，也可只给需要的算子做精度对比，只需要在相关的配置文件（如 `dipu/scripts/autogen_diopi_wrapper/diopi_functions.yaml`）给相应的算子添加 `autocompare: True` 即可。
+算子精度自动对比功能用于确保算子计算结果的正确性，通过将设备参数拷贝到CPU上，对比CPU和设备的计算结果来判断精度是否达标。以下是算子精度自动对比功能的使用例子：
 
 ```shell
-$ unset  DIPU_FORCE_FALLBACK_OPS_LIST # 主要是确保要比较的算子没有强制 fallback 到 cpu, 可选
+$ unset  DIPU_FORCE_FALLBACK_OPS_LIST # 主要是确保要比较的算子没有强制 fallback到CPU, 可选
 $ python
 >>> import torch
 >>> import torch_dipu
@@ -220,11 +213,32 @@ autocompare:    add.out other: allclose
 >>>
 ```
 
-可以看到，CPU 计算结果与设备计算结果 `allclose`，也能看到 CPU 和设备计算结果的 `shape`、`dtype` 等信息。特别的，需要注意以下几个问题：
+可以看到，输出包括 CPU 和设备计算结果的 `shape`、`stride`、`dtype` 等信息， 最终结果是CPU和设备的self和out都是allclose的。
+
+##### 算子精度自动对比功能的设置
+
+算子精度自动对比功能默认不开启，可以设置环境变量`USE_GLOBAL_AUTOCOMPARE`和`SPECIFIED_AUTOCOMPARE_OPS_LIST`来控制该功能，在开启算子自动对比功能前，必须unset  `DIPU_FORCE_FALLBACK_OPS_LIST`
+
+- 可以通过设置环境变量`USE_GLOBAL_AUTOCOMPARE=ON`，开启全局的精度对比，这种情况下所有调用的算子都会进行精度对比，也可以设置为OFF来关闭所有算子的精度自动对比功能
+
+```shell
+# 开启全局的算子精度自动对比功能
+export USE_GLOBAL_AUTOCOMPARE=ON
+```
+
+- 在未开启`USE_GLOBAL_AUTOCOMPARE`的前提下，可以设置`SPECIFIED_AUTOCOMPARE_OPS_LIST`来指定算子开启自动精度对比，支持正则表达式匹配。算子名可以参考[diopi_functions.yaml](https://github.com/DeepLink-org/deeplink.framework/blob/main/dipu/scripts/autogen_diopi_wrapper/diopi_functions.yaml)。
+
+```shell
+# 关闭全局的算子精度自动对比功能，并指定add.*?算子进行对比
+export USE_GLOBAL_AUTOCOMPARE=OFF
+export SPECIFIED_AUTOCOMPARE_OPS_LIST=add.*?
+```
+
+NOTE:
 
-1. `dipu/scripts/autogen_diopi_wrapper/diopi_functions.yaml` 中配置了 `autograd:True` 的算子 (`cross_entropy_loss`、`conv2d`、`dropout`、`dropout_`、`linear`) 暂不支持 *backward* 的精度自动对比。如模型精度对不齐，可根据需要先将这几个算子 fallback 到 CPU 来确定问题。
-2. 随机数生成相关的算子（`dipu/scripts/autogen_diopi_wrapper/diopi_functions.yaml` 中配置了 `autocompare:False`）没有做 `autocompare`，因为结果总是 `not_allclose`。
-3. 对输入做检查是确保算子输入不被意外修改。
+1. 部分算子并不支持自动精度对比功能，可以查看[diopi_functions.yaml](https://github.com/DeepLink-org/deeplink.framework/blob/main/dipu/scripts/autogen_diopi_wrapper/diopi_functions.yaml)，其中的`autocompare`配置项为`disable`即不支持自动精度对比功能，同时也可以修改`diopi_functions.yaml`，将某些算子的`autocompare`配置项设置为`disable`来禁用自动对比功能。
+2. `dipu/scripts/autogen_diopi_wrapper/diopi_functions.yaml` 中配置了 `autograd:True` 的算子 (`cross_entropy_loss`、`conv2d`、`dropout`、`dropout_`、`linear`) 暂不支持 *backward* 的精度自动对比。如模型精度对不齐，可根据需要先将这几个算子 fallback 到 CPU 来确定问题。
+3. 对输入参数(self)做检查是确保算子的输入不被意外修改。
 
 #### 抓取算子参数
 

dipu/scripts/autogen_diopi_wrapper/autogen_diopi_wrapper.py

@@ -9,6 +9,7 @@
     diopi_wrapper_file_template_content,
     diopi_wrapper_function_template_content,
     op_register_template_content,
+    op_register_disable_autocompare_template_content,
     custom_autograd_template_content,
     autocompare_template_content,
     op_with_custom_fallback_register_template_content,
@@ -673,6 +674,10 @@ def create_optional_generator_process_code(arg_name):
 
 op_register_template = CodeTemplate(op_register_template_content)
 
+op_disable_autocompare_register_template = CodeTemplate(
+    op_register_disable_autocompare_template_content
+)
+
 op_with_custom_fallback_register_template = CodeTemplate(
     op_with_custom_fallback_register_template_content
 )
@@ -906,7 +911,7 @@ def functions_code_gen(fun_config):
         fbody += custom_autograd_function_code
         fun_name = wrapper_fun_name
 
-    if fun_config.get("autocompare", False) in [True, "True"] and fun_config.get(
+    if fun_config.get("autocompare") not in ["disable"] and fun_config.get(
         "register_op", True
     ) in [True, "True"]:
         auto_compare_fun_name = fun_name + "_autocompare"
@@ -940,9 +945,11 @@ def functions_code_gen(fun_config):
             ],
         )
         fbody += autocompare_code
-        fun_name = auto_compare_fun_name
 
-    if fun_config.get("custom_fallback", False) in ["False", False]:
+    # generate the OP_register code
+    if fun_config.get("custom_fallback", False) in ["False", False] and fun_config.get(
+        "autocompare", True
+    ) in ["True", True]:
         register_body = op_register_template.substitute(
             register_name=[get_op_name_from_schema(fun_config["schema"])],
             aten_fun_name=["dipu::native::" + fun_name],
@@ -952,6 +959,21 @@ def functions_code_gen(fun_config):
                 )
             ],
         )
+
+    elif fun_config.get("custom_fallback", False) in [
+        "False",
+        False,
+    ] and fun_config.get("autocompare") in ["disable"]:
+        register_body = op_disable_autocompare_register_template.substitute(
+            register_name=[get_op_name_from_schema(fun_config["schema"])],
+            aten_fun_name=["dipu::native::" + fun_name],
+            diopi_fun_name=[
+                get_fun_name_from_cppsignature(diopi_interface).replace(
+                    "diopi", "::diopi"
+                )
+            ],
+        )
+
     else:
         register_body = op_with_custom_fallback_register_template.substitute(
             register_name=[get_op_name_from_schema(fun_config["schema"])],
@@ -974,6 +996,7 @@ def functions_code_gen(fun_config):
                 + fun_name.replace("_autocompare", "")
             ],
         )
+
     return fbody, register_body
 
 
@@ -1039,12 +1062,6 @@ def parse_args():
         type=boolean_string,
         help="whether generate code that prints op args",
     )
-    parser.add_argument(
-        "--autocompare",
-        default=False,
-        type=boolean_string,
-        help="whether generate code that compare device calculation results with cpu calculation results",
-    )
     parser.add_argument(
         "--fun_config_dict",
         type=json.loads,

dipu/scripts/autogen_diopi_wrapper/autogen_wrapped_code.sh

@@ -5,17 +5,16 @@
 DIPU_DIR=$(readlink -f $(dirname $(readlink -f "$0"))/../..)
 AUTOGEN_DIOPI_WRAPPER=$DIPU_DIR/scripts/autogen_diopi_wrapper
 
-USE_AUTOCOMPARE=${1:-OFF}
-UsedVendor=${2:-cuda}
-Torch_VERSION=${3:-2.1.0}
-GENERATED_KERNELS_SCRIPT=${4:-$AUTOGEN_DIOPI_WRAPPER/autogen_diopi_wrapper.py}
-GENERATED_KERNELS_CONFIG=${5:-$AUTOGEN_DIOPI_WRAPPER/diopi_functions.yaml}
-GENERATED_KERNELS=${6:-$DIPU_DIR/torch_dipu/csrc_dipu/aten/ops/AutoGenedKernels.cpp}
+UsedVendor=${1:-cuda}
+Torch_VERSION=${2:-2.1.0}
+GENERATED_KERNELS_SCRIPT=${3:-$AUTOGEN_DIOPI_WRAPPER/autogen_diopi_wrapper.py}
+GENERATED_KERNELS_CONFIG=${4:-$AUTOGEN_DIOPI_WRAPPER/diopi_functions.yaml}
+GENERATED_KERNELS=${5:-$DIPU_DIR/torch_dipu/csrc_dipu/aten/ops/AutoGenedKernels.cpp}
 
 GENERATED_KERNELS_VENDOR=${DIPU_DIR}/third_party/DIOPI/impl/${UsedVendor}/convert_config.yaml
 
 PYTHON_CMD="python3 ${GENERATED_KERNELS_SCRIPT} --out=${GENERATED_KERNELS} --config=${GENERATED_KERNELS_CONFIG} \
-    --autocompare=${USE_AUTOCOMPARE} --print_op_arg=True --use_diopi_adapter=False --print_func_call_info=True \
+    --print_op_arg=True --use_diopi_adapter=False --print_func_call_info=True \
     --fun_config_dict='{\"current_device\":\"${UsedVendor}\",\"current_torch_ver\":\"${Torch_VERSION}\"}'"
 
 if [ -f "$GENERATED_KERNELS_VENDOR" ]; then

dipu/scripts/autogen_diopi_wrapper/diopi_wrapper_template.py

@@ -50,6 +50,7 @@
 #include "csrc_dipu/aten/ops/DIPUCopy.hpp"
 #include "csrc_dipu/aten/ops/NodispatchUtils.hpp"
 #include "csrc_dipu/aten/ops/OpUtils.hpp"
+#include "csrc_dipu/aten/ops/OpRegexMatch.hpp"
 #include "csrc_dipu/base/basedef.h"
 #include "csrc_dipu/diopirt/diopirt_impl.h"
 #include "csrc_dipu/profiler/profiler.h"
@@ -131,6 +132,10 @@
 DIOPI_ATEN_FUNC("$register_name", $diopi_fun_name, $aten_fun_name);
 """
 
+op_register_disable_autocompare_template_content = """
+DIOPI_ATEN_FUNC_DISABLE_AUTOCOMPARE("$register_name", $diopi_fun_name, $aten_fun_name);
+"""
+
 op_with_custom_fallback_register_template_content = """
 DIOPI_ATEN_FUNC_CUSTOM_FALLBACK("$register_name", $diopi_fun_name, $force_fallback /*whether force fallback*/, $aten_fun_name, $fallbackFunc);
 """

dipu/scripts/ci/ascend/ci_ascend_script.sh

@@ -12,8 +12,8 @@ function build_diopi_lib() {
 function config_dipu_ascend_cmake() {
     mkdir -p build && cd ./build
     cmake_args="-DCMAKE_BUILD_TYPE=Release -DDEVICE=ascend -DWITH_DIOPI_LIBRARY=DISABLE"
-    if [ -n "$USE_AUTOCOMPARE" ]; then
-        cmake_args+=" -DUSE_AUTOCOMPARE=${USE_AUTOCOMPARE}"
+    if [ -n "$USE_GLOBAL_AUTOCOMPARE" ]; then
+        cmake_args+=" -DUSE_GLOBAL_AUTOCOMPARE=${USE_GLOBAL_AUTOCOMPARE}"
     fi
     cmake ../ $cmake_args
     cd ../
@@ -22,8 +22,8 @@ function config_dipu_ascend_cmake() {
 function config_all_ascend_cmake() {
     mkdir -p build && cd ./build
     cmake_args="-DCMAKE_BUILD_TYPE=Release -DDEVICE=ascend -DENABLE_COVERAGE=${USE_COVERAGE} -DWITH_DIOPI=INTERNAL"
-    if [ -n "$USE_AUTOCOMPARE" ]; then
-        cmake_args+=" -DUSE_AUTOCOMPARE=${USE_AUTOCOMPARE}"
+    if [ -n "$USE_GLOBAL_AUTOCOMPARE" ]; then
+        cmake_args+=" -DUSE_GLOBAL_AUTOCOMPARE=${USE_GLOBAL_AUTOCOMPARE}"
     fi
     cmake ../ $cmake_args
     cd ../

dipu/torch_dipu/csrc_dipu/CMakeLists.txt

@@ -1,5 +1,4 @@
 #[[ Dependencies ]]
-option(USE_AUTOCOMPARE "whether to use USE_AUTOCOMPARE" OFF)
 
 # Import Python3::Python, Python3_EXECUTABLE
 # Also see https://cmake.org/cmake/help/latest/module/FindPython3.html
@@ -58,7 +57,7 @@ endif()
 
 add_custom_command(
   OUTPUT "${GENERATED_KERNELS}"
-  COMMAND bash -c "${AUTOGEN_CODE_SH} ${USE_AUTOCOMPARE} ${UsedVendor} ${Torch_VERSION} ${GENERATED_KERNELS_SCRIPT} ${GENERATED_KERNELS_CONFIG} ${GENERATED_KERNELS}"
+  COMMAND bash -c "${AUTOGEN_CODE_SH} ${UsedVendor} ${Torch_VERSION} ${GENERATED_KERNELS_SCRIPT} ${GENERATED_KERNELS_CONFIG} ${GENERATED_KERNELS}"
   COMMENT "Generating ${GENERATED_KERNELS}$<$<BOOL:${GENERATED_KERNELS_VENDOR}>: with ${GENERATED_KERNELS_VENDOR}>"
   DEPENDS
     "${GENERATED_KERNELS_SCRIPT}"
@@ -76,6 +75,7 @@ set(TORCH_DIPU_SOURCE
   aten/ops/PinMemoryKernel.cpp
   aten/ops/EmptyOpsKernel.cpp
   aten/ops/CustomFallbackFunctionsForCopy.cpp
+  aten/ops/OpRegexMatch.cpp
   aten/RegisterDIPU.cpp
   aten/CPUFallback.cpp
 

dipu/torch_dipu/csrc_dipu/aten/RegisterDIPU.cpp

@@ -21,57 +21,6 @@
 namespace dnative = dipu::native::dipu_aten;
 
 namespace dipu {
-namespace {
-
-std::vector<std::regex> load_fallback_matcher() {
-  auto constexpr env_name = "DIPU_FORCE_FALLBACK_OPS_LIST";
-  auto constexpr file_name = ".dipu_force_fallback_op_list.config";
-
-  auto append = [](std::istream& input, std::vector<std::regex>& output) {
-    auto constexpr separator = ',';
-
-    auto line = std::string();
-    while (std::getline(input, line)) {
-      auto buffer = std::istringstream(line);
-      auto pattern = std::string();
-      while (std::getline(buffer, pattern, separator)) {
-        if (pattern.empty()) {
-          continue;
-        }
-        try {
-          output.emplace_back(pattern);
-        } catch (const std::regex_error& e) {
-          TORCH_CHECK(false, e.what());
-        }
-      }
-    }
-  };
-
-  auto list = std::vector<std::regex>();
-  if (auto env = std::getenv(env_name)) {
-    auto iss = std::istringstream(env);
-    append(iss, list);
-  }
-  if (auto file = std::ifstream(file_name, std::ios::binary)) {
-    append(file, list);
-  }
-  return list;
-}
-
-auto const force_fallback_matchers = load_fallback_matcher();
-
-}  // end of namespace
-
-bool get_force_fallback(const char* opname) {
-  if (force_fallback_matchers.empty() || opname == nullptr) {
-    return false;
-  }
-
-  return std::any_of(
-      force_fallback_matchers.begin(), force_fallback_matchers.end(),
-      [&opname](auto& matcher) { return std::regex_match(opname, matcher); });
-}
-
 namespace native {
 void cpu_fallback(const c10::OperatorHandle& op, torch::jit::Stack* stack);
 }  // end of namespace native

dipu/torch_dipu/csrc_dipu/aten/RegisterDIPU.hpp

@@ -8,16 +8,10 @@
 
 #include <torch/library.h>
 
+#include "csrc_dipu/aten/ops/OpRegexMatch.hpp"
 #include "csrc_dipu/aten/ops/OpUtils.hpp"
 
-namespace dipu {
-
-bool get_force_fallback(const char* opname);
-
-};  // namespace dipu
-
 namespace at {
-
 void dipu_fallback(const c10::OperatorHandle& op, DispatchKeySet dispatch_keys,
                    torch::jit::Stack* stack);
 
@@ -52,11 +46,32 @@ void dipu_fallback(const c10::OperatorHandle& op, DispatchKeySet dispatch_keys,
 // It mat be necessary to determine whether to keep torchop default impl
 // for non-custom ops through function dipuKeepTorchopDefaultImpl firstly in the
 // future, and we use force fallback to keep torchop default impl now.
-#define DIOPI_ATEN_FUNC(opname, diopiFunc, wapperFunc)                       \
+#define addAutoCompare(wrapperFunc) wrapperFunc##_autocompare
+#define DIOPI_ATEN_FUNC(opname, diopiFunc, wrapperFunc)                      \
+  do {                                                                       \
+    if ((reinterpret_cast<void*>(diopiFunc) != nullptr) &&                   \
+        (!dipu::whetherOpMatch(opname, fallbackMatchers))) {                 \
+      if (dipu::whetherAutoCompare(opname, autocompareMatchers)) {           \
+        m.impl(opname, TORCH_FN(addAutoCompare(wrapperFunc)));               \
+      } else {                                                               \
+        m.impl(opname, TORCH_FN(wrapperFunc));                               \
+      }                                                                      \
+    } else {                                                                 \
+      if ((reinterpret_cast<void*>(diopiFunc) == nullptr)) {                 \
+        DIPU_OP_LOG_WARNING_ONCE(#diopiFunc << " is not yet implemented, "); \
+      } else {                                                               \
+        DIPU_OP_LOG_WARNING_ONCE("force fallback has been set, ");           \
+      }                                                                      \
+      DIPU_OP_LOG_WARNING_ONCE((opname) << " will be fallback to cpu"        \
+                                        << "\n");                            \
+    }                                                                        \
+  } while (false);
+
+#define DIOPI_ATEN_FUNC_DISABLE_AUTOCOMPARE(opname, diopiFunc, wrapperFunc)  \
   do {                                                                       \
     if ((reinterpret_cast<void*>(diopiFunc) != nullptr) &&                   \
-        (!dipu::get_force_fallback(opname))) {                               \
-      m.impl(opname, TORCH_FN(wapperFunc));                                  \
+        (!dipu::whetherOpMatch(opname, fallbackMatchers))) {                 \
+      m.impl(opname, TORCH_FN(wrapperFunc));                                 \
     } else {                                                                 \
       if ((reinterpret_cast<void*>(diopiFunc) == nullptr)) {                 \
         DIPU_OP_LOG_WARNING_ONCE(#diopiFunc << " is not yet implemented, "); \
@@ -71,14 +86,15 @@ void dipu_fallback(const c10::OperatorHandle& op, DispatchKeySet dispatch_keys,
 // Determine whether to keep torchop default impl for custom ops through
 // function dipuKeepTorchopDefaultImpl firstly.
 #define DIOPI_ATEN_FUNC_CUSTOM_FALLBACK(opname, diopi_func, force_fallback,   \
-                                        wapper_func, custom_fallback_func)    \
+                                        wrapper_func, custom_fallback_func)   \
   do {                                                                        \
     if (dipu::native::dipuKeepTorchopDefaultImpl(opname)) {                   \
       break;                                                                  \
     }                                                                         \
     if ((reinterpret_cast<void*>(diopi_func) != nullptr) &&                   \
-        !((force_fallback) || dipu::get_force_fallback(opname))) {            \
-      m.impl(opname, TORCH_FN(wapper_func));                                  \
+        !((force_fallback) ||                                                 \
+          dipu::whetherOpMatch(opname, fallbackMatchers))) {                  \
+      m.impl(opname, TORCH_FN(wrapper_func));                                 \
     } else {                                                                  \
       if ((reinterpret_cast<void*>(diopi_func) == nullptr)) {                 \
         DIPU_OP_LOG_WARNING_ONCE(#diopi_func << " is not yet implemented, "); \