mindstudio-probe 1.0.1__py3-none-any.whl

msprobe/pytorch/free_benchmark/result_handlers/fix_handler.py

@@ -0,0 +1,24 @@
+from typing import Any
+
+from msprobe.pytorch.free_benchmark.common.params import DataParams
+from msprobe.pytorch.free_benchmark.common.utils import Tools
+from msprobe.pytorch.free_benchmark.result_handlers.base_handler import FuzzHandler
+from msprobe.pytorch.free_benchmark import logger
+
+
+class FixHandler(FuzzHandler):
+
+    def get_threshold(self, dtype):
+        return self._get_default_threshold(dtype)
+
+    def handle(self, data_params: DataParams) -> Any:
+        try:
+            return Tools.convert_fuzz_output_to_origin(
+                data_params.original_result, data_params.perturbed_result
+            )
+        except Exception as e:
+            logger.warning_on_rank_0(
+                f"[msprobe] Free Benchmark: For {self.params.api_name} "
+                f"Fix output failed. "
+            )
+        return data_params.original_result

msprobe/pytorch/free_benchmark/result_handlers/handler_factory.py

@@ -0,0 +1,31 @@
+from msprobe.pytorch.free_benchmark import FreeBenchmarkException
+from msprobe.pytorch.free_benchmark.common.constant import PreheatConfig
+from msprobe.pytorch.free_benchmark.common.enums import HandlerType
+from msprobe.pytorch.free_benchmark.common.params import HandlerParams
+from msprobe.pytorch.free_benchmark.result_handlers.check_handler import CheckerHandler
+from msprobe.pytorch.free_benchmark.result_handlers.preheat_handler import PreheatHandler
+from msprobe.pytorch.free_benchmark.result_handlers.fix_handler import FixHandler
+
+
+class FuzzHandlerFactory:
+
+    result_handlers = {
+        HandlerType.CHECK: CheckerHandler,
+        HandlerType.FIX: FixHandler,
+        HandlerType.PREHEAT: PreheatHandler,
+    }
+
+    @staticmethod
+    def create(params: HandlerParams):
+        if_preheat = params.preheat_config.get(PreheatConfig.IF_PREHEAT)
+        if not if_preheat:
+            handler = FuzzHandlerFactory.result_handlers.get(params.handler_type)
+        else:
+            handler = FuzzHandlerFactory.result_handlers.get(HandlerType.PREHEAT)
+            # TODO
+        if not handler:
+            raise FreeBenchmarkException(
+                FreeBenchmarkException.UnsupportedType,
+                f"无标杆工具支持 [ {HandlerType.CHECK}、{HandlerType.FIX}] 形式",
+            )
+        return handler(params)

msprobe/pytorch/free_benchmark/result_handlers/preheat_handler.py

@@ -0,0 +1,170 @@
+import math
+from typing import Any
+
+from msprobe.pytorch.free_benchmark import logger
+from msprobe.pytorch.free_benchmark.common.constant import ThresholdConfig
+from msprobe.pytorch.free_benchmark.common.counter import preheat_counter
+from msprobe.pytorch.free_benchmark.common.enums import DeviceType
+from msprobe.pytorch.free_benchmark.common.params import DataParams, HandlerParams
+from msprobe.pytorch.free_benchmark.common.utils import Tools
+from msprobe.pytorch.free_benchmark.compare.single_benchmark import SingleCompare
+from msprobe.pytorch.free_benchmark.result_handlers.base_handler import FuzzHandler
+
+
+class PreheatHandler(FuzzHandler):
+
+    def __init__(self, params: HandlerParams) -> None:
+        super().__init__(params)
+        self.pure_name = Tools.get_pure_api_name(self.params.api_name)
+
+    def get_threshold(self, dtype):
+        return preheat_counter.get_api_thd(self.pure_name, dtype)
+
+    def compare_npu_and_cpu(self, data_params: DataParams):
+        args = Tools.convert_device_and_dtype(
+            data_params.args, DeviceType.CPU, change_dtype=True
+        )
+        kwargs = Tools.convert_device_and_dtype(
+            data_params.kwargs, DeviceType.CPU, change_dtype=True
+        )
+        cpu_result = data_params.origin_func(*args, **kwargs)
+        return SingleCompare().compare_seq(data_params.original_result, cpu_result)
+
+    def preheat(self, max_fuzz_ratio, cpu_consistent, first_dtype):
+        # 存储当前step所有输出比值和对应npu\cpu比对结果
+        preheat_counter.update_preheat_record(
+            self.pure_name,
+            first_dtype,
+            (max_fuzz_ratio, cpu_consistent),
+        )
+        if self._need_adjust_threshold():
+            self._adjust_threshold()
+
+    def handle(self, data_params: DataParams) -> Any:
+
+        if isinstance(data_params.perturbed_result, bool) or not Tools.is_float_tensor(
+                data_params.perturbed_result
+        ):
+            return data_params.original_result
+
+        if self.params.step == 0:
+            preheat_counter.add_one_step_used_api(self.pure_name)
+            return data_params.original_result
+
+        # 如果当前api,step需要预热
+        npu_consistent, max_fuzz_ratio = self.cmp_output_npu(data_params)
+        data_params.is_consistent = npu_consistent
+
+        preheat_counter.check_step(self.params.step)
+
+        if self.params.preheat_config.get("preheat_step") <= self.params.step:
+            return data_params.original_result
+
+        if not data_params.grad_unequal_flag:
+            data_params.grad_unequal_flag = True
+            data_params.is_consistent = False
+            return data_params.original_result
+        preheat_counter.add_api_called_time(self.pure_name)
+
+        if not self._is_take_a_sample():
+            return data_params.original_result
+
+        cpu_consistent = True
+        try:
+            cpu_consistent = self.compare_npu_and_cpu(data_params)
+        except Exception as e:
+            logger.warning_on_rank_0(
+                f"[msprobe] Free Benchmark: For {self.params.api_name}, "
+                f"when campare to cpu exception raise {e}"
+            )
+        try:
+            first_dtype = Tools.get_first_tensor_dtype(data_params.original_result)
+        except RuntimeError:
+            logger.warning_on_rank_0(
+                f"[msprobe] Free Benchmark: For {self.params.api_name}, "
+                f"the output sequence does not contain tensors."
+            )
+        if preheat_counter.get_api_preheat(self.pure_name, str(first_dtype)):
+            self.preheat(max_fuzz_ratio, cpu_consistent, first_dtype)
+
+        return data_params.original_result
+
+    def _is_take_a_sample(self) -> bool:
+        need_sample_set = self._get_need_sample_set()
+        curr_called_seq = preheat_counter.get_api_called_time(self.pure_name)
+        res = curr_called_seq in need_sample_set
+        if res:
+            total_count = preheat_counter.get_one_step_used_api(self.pure_name)
+            logger.info_on_rank_0(
+                f"[msprobe] Free benchmark: preheat sample in step{self.params.step}"
+                f"api_name {self.params.api_name}, "
+                f"curr_called_seq: {curr_called_seq}/{total_count}"
+            )
+            preheat_counter.add_api_sample_time(self.pure_name)
+        return res
+
+    def _get_sample_count_per_step(self) -> set:
+        """
+        每一个step中应该采集的样本数
+        """
+        total_count = preheat_counter.get_one_step_used_api(self.pure_name)
+        preheat_step = self.params.preheat_config.get("preheat_step")
+        max_sample = self.params.preheat_config.get("max_sample")
+        return min(math.ceil(total_count / preheat_step), max_sample)
+
+    def _get_need_sample_set(self):
+        """
+        需要采集的api集合
+        """
+        # 每一步样本数
+        total_count = preheat_counter.get_one_step_used_api(self.pure_name)
+        sample_count_per_step = self._get_sample_count_per_step()
+        need_sample_set = set()
+        prehead_step = self.params.preheat_config.get("preheat_step")
+        for i in range(1, sample_count_per_step + 1):
+            count = (prehead_step * (i - 1) + self.params.step) % total_count
+            if count == 0:
+                count = total_count
+            need_sample_set.add(count)
+        return need_sample_set
+
+    def _need_adjust_threshold(self) -> bool:
+        sample_count_per_step = self._get_sample_count_per_step()
+        sampled_time = preheat_counter.get_api_sample_time(self.pure_name)
+        res = sampled_time >= sample_count_per_step
+        return res
+
+    def _adjust_threshold_for_dtype(self, dtype_str, compare_result):
+        con_ratio = [ratio for ratio, is_consistent in compare_result if is_consistent]
+        incon_ratio = [
+            ratio for ratio, is_consistent in compare_result if not is_consistent
+        ]
+        old_thd = preheat_counter.get_api_thd(self.pure_name, dtype_str)
+        new_thd = old_thd
+        # 正例负例都存在
+        if con_ratio and incon_ratio:
+            if min(incon_ratio) > max(con_ratio):
+                new_thd = min(min(incon_ratio), old_thd)
+                preheat_counter.set_api_preheat(self.pure_name, dtype_str, is_preheat=False)
+        elif con_ratio:
+            # 存在漏报
+            if max(con_ratio) > old_thd:
+                new_thd = 1 + ((old_thd - 1) * ThresholdConfig.API_THD_STEP)
+            else:
+                new_thd = 1 + ((old_thd - 1) / ThresholdConfig.API_THD_STEP)
+        else:
+            new_thd = min(min(incon_ratio), old_thd)
+            preheat_counter.set_api_preheat(self.pure_name, dtype_str, is_preheat=False)
+        return new_thd
+
+    def _adjust_threshold(self):
+        for dtype_str, compare_result in preheat_counter.preheat_record[
+            self.pure_name
+        ].items():
+            new_thd = self._adjust_threshold_for_dtype(dtype_str, compare_result)
+            threshold = self._get_default_threshold(
+                preheat_counter.dtype_map.get(dtype_str)
+            )
+            preheat_counter.update_api_thd(
+                self.pure_name, dtype_str, new_thd, threshold
+            )

msprobe/pytorch/functional/dump_module.py

@@ -0,0 +1,39 @@
+import torch.nn as nn
+from msprobe.pytorch.common.log import logger
+from msprobe.core.common.const import Const
+from msprobe.pytorch.hook_module.api_registry import api_register
+from msprobe.pytorch.debugger.precision_debugger import PrecisionDebugger
+from msprobe.core.common.exceptions import MsaccException
+from msprobe.core.data_dump.scope import BaseScope
+
+module_count = {}
+
+
+def module_dump(module, dump_name):
+    if not isinstance(module, nn.Module):
+        logger.error("The parameter:module in module_dump is not a Module subclass.")
+        raise MsaccException(MsaccException.INVALID_PARAM_ERROR)
+    if not isinstance(dump_name, str):
+        logger.error("The parameter:dump_name in module_dump is not a str type.")
+        raise MsaccException(MsaccException.INVALID_PARAM_ERROR)
+    api_register.api_originality()
+    if dump_name not in module_count:
+        module_count[dump_name] = 0
+    else:
+        module_count[dump_name] += 1
+    dump_name = dump_name + Const.SEP + str(module_count.get(dump_name)) + Const.SEP
+
+    pdg = PrecisionDebugger()
+    _, forward_hook, backward_hook = pdg.service.build_hook(BaseScope.Module_Type_Module, dump_name)
+    module.register_forward_hook(forward_hook, with_kwargs=True)
+    module.register_full_backward_hook(backward_hook)
+
+    module.register_forward_pre_hook(pdg.service.module_processor.node_hook(dump_name + Const.FORWARD, Const.START))
+    module.register_forward_hook(pdg.service.module_processor.node_hook(dump_name + Const.FORWARD, Const.STOP))
+    module.register_full_backward_pre_hook(
+        pdg.service.module_processor.node_hook(dump_name + Const.BACKWARD, Const.START))
+    module.register_full_backward_hook(pdg.service.module_processor.node_hook(dump_name + Const.BACKWARD, Const.STOP))
+
+
+def module_dump_end():
+    api_register.api_modularity()

msprobe/pytorch/hook_module/__init__.py

@@ -0,0 +1 @@
+from .wrap_functional import remove_dropout

msprobe/pytorch/hook_module/api_registry.py

@@ -0,0 +1,161 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+# Copyright (C) 2022-2023. Huawei Technologies Co., Ltd. All rights reserved.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""
+
+import torch
+import torch.distributed as dist
+
+from msprobe.pytorch.hook_module import wrap_torch, wrap_functional, wrap_tensor, wrap_vf, wrap_distributed, wrap_aten
+from msprobe.pytorch.hook_module.wrap_aten import get_aten_ops
+from msprobe.pytorch.hook_module.wrap_distributed import get_distributed_ops
+from msprobe.pytorch.hook_module.wrap_functional import get_functional_ops
+from msprobe.pytorch.hook_module.wrap_tensor import get_tensor_ops
+from msprobe.pytorch.hook_module.wrap_torch import get_torch_ops
+from msprobe.pytorch.hook_module.wrap_vf import get_vf_ops
+from msprobe.pytorch.common.utils import torch_without_guard_version, npu_distributed_api, is_gpu
+from msprobe.core.common.const import Const
+
+torch_version_above_2 = torch.__version__.split('+')[0] > '2.0'
+
+if not is_gpu:
+    import torch_npu
+    from . import wrap_npu_custom
+    from .wrap_npu_custom import get_npu_ops
+
+
+class ApiRegistry:
+    def __init__(self):
+        self.tensor_ori_attr = {}
+        self.torch_ori_attr = {}
+        self.functional_ori_attr = {}
+        self.distributed_ori_attr = {}
+        self.npu_distributed_ori_attr = {}
+        self.vf_ori_attr = {}
+        self.aten_ori_attr = {}
+        self.torch_npu_ori_attr = {}
+
+        self.tensor_hook_attr = {}
+        self.torch_hook_attr = {}
+        self.functional_hook_attr = {}
+        self.distributed_hook_attr = {}
+        self.npu_distributed_hook_attr = {}
+        self.vf_hook_attr = {}
+        self.aten_hook_attr = {}
+        self.torch_npu_hook_attr = {}
+
+    @staticmethod
+    def store_ori_attr(ori_api_group, api_list, api_ori_attr):
+        for api in api_list:
+            if '.' in api:
+                sub_module_name, sub_op = api.rsplit('.', 1)
+                sub_module = getattr(ori_api_group, sub_module_name)
+                api_ori_attr[api] = getattr(sub_module, sub_op)
+            else:
+                api_ori_attr[api] = getattr(ori_api_group, api)
+
+    @staticmethod
+    def set_api_attr(api_group, attr_dict):
+        for api, api_attr in attr_dict.items():
+            if '.' in api:
+                sub_module_name, sub_op = api.rsplit('.', 1)
+                sub_module = getattr(api_group, sub_module_name, None)
+                if sub_module is not None:
+                    setattr(sub_module, sub_op, api_attr)
+            else:
+                setattr(api_group, api, api_attr)
+
+    def api_modularity(self):
+        self.set_api_attr(torch.Tensor, self.tensor_hook_attr)
+        self.set_api_attr(torch, self.torch_hook_attr)
+        self.set_api_attr(torch.nn.functional, self.functional_hook_attr)
+        self.set_api_attr(dist, self.distributed_hook_attr)
+        self.set_api_attr(dist.distributed_c10d, self.distributed_hook_attr)
+        if not is_gpu and not torch_without_guard_version:
+            self.set_api_attr(torch_npu.distributed, self.npu_distributed_hook_attr)
+            self.set_api_attr(torch_npu.distributed.distributed_c10d, self.npu_distributed_hook_attr)
+        if torch_version_above_2:
+            self.set_api_attr(torch.ops.aten, self.aten_hook_attr)
+        self.set_api_attr(torch._VF, self.vf_hook_attr)
+        if not is_gpu:
+            self.set_api_attr(torch_npu, self.torch_npu_hook_attr)
+
+    def api_originality(self):
+        self.set_api_attr(torch.Tensor, self.tensor_ori_attr)
+        self.set_api_attr(torch, self.torch_ori_attr)
+        self.set_api_attr(torch.nn.functional, self.functional_ori_attr)
+        self.set_api_attr(dist, self.distributed_ori_attr)
+        self.set_api_attr(dist.distributed_c10d, self.distributed_ori_attr)
+        if not is_gpu and not torch_without_guard_version:
+            self.set_api_attr(torch_npu.distributed, self.npu_distributed_ori_attr)
+            self.set_api_attr(torch_npu.distributed.distributed_c10d, self.npu_distributed_ori_attr)
+        if torch_version_above_2:
+            self.set_api_attr(torch.ops.aten, self.aten_ori_attr)
+        self.set_api_attr(torch._VF, self.vf_ori_attr)
+        if not is_gpu:
+            self.set_api_attr(torch_npu, self.torch_npu_ori_attr)
+
+    def initialize_hook(self, hook):
+        self.store_ori_attr(torch.Tensor, get_tensor_ops(), self.tensor_ori_attr)
+        wrap_tensor.wrap_tensor_ops_and_bind(hook)
+        for attr_name in dir(wrap_tensor.HOOKTensor):
+            if attr_name.startswith(Const.ATTR_NAME_PREFIX):
+                self.tensor_hook_attr[attr_name[5:]] = getattr(wrap_tensor.HOOKTensor, attr_name)
+
+        self.store_ori_attr(torch, get_torch_ops(), self.torch_ori_attr)
+        wrap_torch.wrap_torch_ops_and_bind(hook)
+        for attr_name in dir(wrap_torch.HOOKTorchOP):
+            if attr_name.startswith(Const.ATTR_NAME_PREFIX):
+                self.torch_hook_attr[attr_name[5:]] = getattr(wrap_torch.HOOKTorchOP, attr_name)
+
+        self.store_ori_attr(torch.nn.functional, get_functional_ops(), self.functional_ori_attr)
+        wrap_functional.wrap_functional_ops_and_bind(hook)
+        for attr_name in dir(wrap_functional.HOOKFunctionalOP):
+            if attr_name.startswith(Const.ATTR_NAME_PREFIX):
+                self.functional_hook_attr[attr_name[5:]] = getattr(wrap_functional.HOOKFunctionalOP, attr_name)
+
+        self.store_ori_attr(dist, get_distributed_ops(), self.distributed_ori_attr)
+        wrap_distributed.wrap_distributed_ops_and_bind(hook)
+        if not is_gpu and not torch_without_guard_version:
+            self.store_ori_attr(torch_npu.distributed, npu_distributed_api, self.npu_distributed_ori_attr)
+        for attr_name in dir(wrap_distributed.HOOKDistributedOP):
+            if attr_name.startswith(Const.ATTR_NAME_PREFIX):
+                self.distributed_hook_attr[attr_name[5:]] = getattr(wrap_distributed.HOOKDistributedOP, attr_name)
+                if not is_gpu and not torch_without_guard_version and attr_name[5:] in npu_distributed_api:
+                    self.npu_distributed_hook_attr[attr_name[5:]] = getattr(wrap_distributed.HOOKDistributedOP,
+                                                                            attr_name)
+
+        if torch_version_above_2:
+            self.store_ori_attr(torch.ops.aten, get_aten_ops(), self.aten_ori_attr)
+            wrap_aten.wrap_aten_ops_and_bind(hook)
+            for attr_name in dir(wrap_aten.HOOKAtenOP):
+                if attr_name.startswith(Const.ATTR_NAME_PREFIX):
+                    self.aten_hook_attr[attr_name[5:]] = getattr(wrap_aten.HOOKAtenOP, attr_name)
+
+        self.store_ori_attr(torch._VF, get_vf_ops(), self.vf_ori_attr)
+        wrap_vf.wrap_vf_ops_and_bind(hook)
+        for attr_name in dir(wrap_vf.HOOKVfOP):
+            if attr_name.startswith(Const.ATTR_NAME_PREFIX):
+                self.vf_hook_attr[attr_name[5:]] = getattr(wrap_vf.HOOKVfOP, attr_name)
+
+        if not is_gpu:
+            self.store_ori_attr(torch_npu, get_npu_ops(), self.torch_npu_ori_attr)
+            wrap_npu_custom.wrap_npu_ops_and_bind(hook)
+            for attr_name in dir(wrap_npu_custom.HOOKNpuOP):
+                if attr_name.startswith(Const.ATTR_NAME_PREFIX):
+                    self.torch_npu_hook_attr[attr_name[5:]] = getattr(wrap_npu_custom.HOOKNpuOP, attr_name)
+
+
+api_register = ApiRegistry()

msprobe/pytorch/hook_module/hook_module.py

@@ -0,0 +1,109 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+# Copyright (C) 2019-2020. Huawei Technologies Co., Ltd. All rights reserved.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""
+
+import functools
+import threading
+import torch
+import torch.nn as nn
+import torch.utils.hooks as full_hooks
+from msprobe.core.common.const import Const
+
+
+class HOOKModule(nn.Module):
+    module_count = {}
+    inner_stop_hook = {}
+
+    def __init__(self, build_hook) -> None:
+        super(HOOKModule, self).__init__()
+        self.has_overflow = False
+        self.prefix = ""
+        self.current_thread = threading.current_thread().ident
+        if self.current_thread not in HOOKModule.inner_stop_hook:
+            HOOKModule.inner_stop_hook[self.current_thread] = False
+        self.stop_hook = HOOKModule.inner_stop_hook.get(self.current_thread, False)
+
+        if not self.stop_hook:
+            if hasattr(self, "prefix_op_name_"):
+                self.prefix = self.prefix_op_name_
+
+            if self.prefix not in HOOKModule.module_count:
+                HOOKModule.module_count[self.prefix] = 1
+                self.prefix += '0' + Const.SEP
+            else:
+                HOOKModule.module_count[self.prefix] += 1
+                self.prefix = self.prefix + str(HOOKModule.module_count[self.prefix] - 1) + Const.SEP
+            forward_pre_hook, forward_hook, backward_hook = build_hook(self.prefix)
+            self.register_forward_pre_hook(forward_pre_hook, with_kwargs=True)
+            self.register_forward_hook(forward_hook, with_kwargs=True)
+            self.register_backward_hook(backward_hook)
+
+    def __call__(self, *input, **kwargs):
+        changed = False
+        if not self.stop_hook:
+            HOOKModule.inner_stop_hook[self.current_thread] = True
+            changed = True
+        result = self._call_func(*input, **kwargs)
+        if changed:
+            HOOKModule.inner_stop_hook[self.current_thread] = False
+        return result
+
+    def _call_func(self, *input, **kwargs):
+        full_backward_hooks, non_full_backward_hooks = [], []
+        if len(self._backward_hooks) > 0:
+            full_backward_hooks, non_full_backward_hooks = self._get_backward_hooks()
+        for hook in self._forward_pre_hooks.values():
+            result_input, result_kwargs = hook(self, input, kwargs)
+            if result_input is not None:
+                if not isinstance(result_input, tuple):
+                    result_input = (result_input,)
+                input = result_input
+            if result_kwargs is not None:
+                kwargs = result_kwargs
+        bw_hook = None
+        if len(full_backward_hooks) > 0:
+            bw_hook = full_hooks.BackwardHook(self, full_backward_hooks)
+            input = bw_hook.setup_input_hook(input)
+        if torch._C._get_tracing_state():
+            result = self._slow_forward(*input, **kwargs)
+        else:
+            result = self.forward(*input, **kwargs)
+        for hook in self._forward_hooks.values():
+            hook_result = hook(self, input, kwargs, result)
+            if hook_result is not None:
+                result = hook_result
+        if bw_hook:
+            result = bw_hook.setup_output_hook(result)
+        if len(non_full_backward_hooks) > 0:
+            var = result
+            while not isinstance(var, torch.Tensor):
+                if isinstance(var, dict):
+                    var = next((v for v in var.values() if isinstance(v, torch.Tensor)))
+                elif isinstance(var, (list, tuple)):
+                    if var:
+                        var = var[0]
+                    else:
+                        return result
+                else:
+                    return result
+            grad_fn = var.grad_fn
+            if grad_fn is not None:
+                for hook in non_full_backward_hooks:
+                    wrapper = functools.partial(hook, self)
+                    functools.update_wrapper(wrapper, hook)
+                    grad_fn.register_hook(wrapper)
+                self._maybe_warn_non_full_backward_hook(input, result, grad_fn)
+        return result