mindstudio-probe 8.1.1__py3-none-any.whl → 8.1.2__py3-none-any.whl

msprobe/mindspore/debugger/precision_debugger.py

@@ -20,7 +20,7 @@ import mindspore as ms
 from mindspore._c_expression import MSContext
 
 from msprobe.core.common.const import Const, MsgConst
-from msprobe.core.common.utils import check_token_range
+from msprobe.core.common.utils import check_token_range, ThreadSafe
 from msprobe.core.common.runtime import Runtime
 from msprobe.core.debugger.precision_debugger import BasePrecisionDebugger
 from msprobe.mindspore.cell_processor import CellProcessor
@@ -57,18 +57,14 @@ ConfigParameters = namedtuple("ConfigParameters", ["config_path", "task", "dump_
 
 class PrecisionDebugger(BasePrecisionDebugger):
 
-    def __new__(cls, config_path=None, task=None, dump_path=None,
-                level=None, step=None, opt=None):
-        if not cls._instance:
-            cls._instance = super().__new__(cls)
-            cls._instance.initialized = False
-            cls._instance.config = None
-            cls.service = None
-            cls.first_start = False
-        return cls._instance
-
-    def __init__(self, config_path=None, task=None, dump_path=None,
-                 level=None, step=None):
+    def __init__(
+            self,
+            config_path=None,
+            task=None,
+            dump_path=None,
+            level=None,
+            step=None
+    ):
         if self.initialized:
             return
         set_register_backward_hook_functions()
@@ -81,13 +77,15 @@ class PrecisionDebugger(BasePrecisionDebugger):
         self.common_config.dump_path = dump_path if dump_path else self.common_config.dump_path
         self.config = DebuggerConfig(self.common_config, self.task_config)
 
-        if self._need_msprobe_c() and _msprobe_c:
+        if self._is_kernel_dump() and not self.task_config.is_regex_valid:
+            raise ValueError('Illegal regular expressions exist in the list.')
+
+        if self._is_kernel_dump() and _msprobe_c:
             os.environ["MS_HOOK_ENABLE"] = "on"
             _msprobe_c._PrecisionDebugger(framework="MindSpore", config_path=config_path)
 
         self.config.execution_mode = self._get_execution_mode()
         if self._need_service():
-            self.config.check_config_with_l2()
             self.service = MindsporeService(self.config)
 
         Runtime.step_count = 0
@@ -119,8 +117,6 @@ class PrecisionDebugger(BasePrecisionDebugger):
 
     @staticmethod
     def _is_graph_dump(config: DebuggerConfig):
-        if config.level != MsConst.KERNEL:
-            return False
         if not config.list:
             return True
         is_graph = any(item.startswith("name-regex") for item in config.list)
@@ -132,28 +128,23 @@ class PrecisionDebugger(BasePrecisionDebugger):
         instance = cls._get_instance()
         if instance is None:
             return
-        if cls._need_msprobe_c() and _msprobe_c:
-            _msprobe_c._PrecisionDebugger().start()
-        check_token_range(token_range)
-        instance.config.execution_mode = cls._get_execution_mode()
-        if cls._need_service():
-            if not instance.service:
-                instance.service = MindsporeService(instance.config)
-            instance.config.check_model(model, token_range)
-            instance.service.start(model, token_range)
+        if cls._is_kernel_dump():
+            cls._start_kernel_dump()
         else:
-            if not instance.first_start:
-                get_api_register().restore_all_api()
-                handler = TaskHandlerFactory.create(instance.config, model)
-                handler.handle()
-                if enable_dynamic_kbyk_dump:
-                    _set_init_iter(0)
-            if enable_dynamic_kbyk_dump:
-                is_valid_rank = (not instance.config.rank or Runtime.rank_id in instance.config.rank)
-                is_valid_step = (not instance.config.step or Runtime.step_count in instance.config.step)
-                if is_valid_rank and is_valid_step:
-                    _dump_start()
-            Runtime.is_running = True
+            check_token_range(token_range)
+            instance.config.execution_mode = cls._get_execution_mode()
+            if cls._need_service():
+                with ThreadSafe():
+                    if not instance.service:
+                        instance.service = MindsporeService(instance.config)
+                    instance.config.check_model(model, token_range)
+                    instance.service.start(model, token_range)
+            else:
+                if not instance.first_start:
+                    get_api_register().restore_all_api()
+                    handler = TaskHandlerFactory.create(instance.config, model)
+                    handler.handle()
+                Runtime.is_running = True
         instance.first_start = True
 
     @classmethod
@@ -165,14 +156,15 @@ class PrecisionDebugger(BasePrecisionDebugger):
         if instance.task == Const.GRAD_PROBE:
             instance.gm.stop()
         if instance.service:
-            instance.service.stop()
+            with ThreadSafe():
+                instance.service.stop()
         else:
             Runtime.is_running = False
         if enable_dynamic_kbyk_dump:
             _dump_stop()
-        if cls._need_msprobe_c() and _msprobe_c:
+        if cls._is_kernel_dump() and _msprobe_c:
             _msprobe_c._PrecisionDebugger().stop()
-    
+
     @classmethod
     def step(cls):
         instance = cls._get_instance()
@@ -180,12 +172,13 @@ class PrecisionDebugger(BasePrecisionDebugger):
             return
 
         if instance.service:
-            instance.service.step()
+            with ThreadSafe():
+                instance.service.step()
         if is_graph_mode_cell_dump_allowed(instance.config):
             GraphModeCellDump.step()
         if enable_dynamic_kbyk_dump:
             _dump_step(1)
-        if cls._need_msprobe_c() and _msprobe_c:
+        if cls._is_kernel_dump() and _msprobe_c:
             _msprobe_c._PrecisionDebugger().step()
 
         HOOKCell.cell_count = defaultdict(int)
@@ -193,6 +186,7 @@ class PrecisionDebugger(BasePrecisionDebugger):
         Runtime.step_count += 1
 
     @classmethod
+    @ThreadSafe.synchronized
     def monitor(cls, opt):
         instance = cls._instance
         if not instance:
@@ -202,6 +196,7 @@ class PrecisionDebugger(BasePrecisionDebugger):
         instance.gm.monitor(opt)
 
     @classmethod
+    @ThreadSafe.synchronized
     def save(cls, variable, name, save_backward=True):
         instance = cls._instance
         if not instance:
@@ -224,14 +219,41 @@ class PrecisionDebugger(BasePrecisionDebugger):
         instance = cls._instance
         if not instance:
             raise Exception(MsgConst.NOT_CREATED_INSTANCE)
+        if instance.config.level_ori == Const.LEVEL_L2:
+            return False
         if instance.config.execution_mode != MsConst.PYNATIVE_MODE:
             return False
         else:
-            return instance.config.task != Const.FREE_BENCHMARK and not instance._is_graph_dump(instance.config)
+            return instance.config.task != Const.FREE_BENCHMARK
 
     @classmethod
-    def _need_msprobe_c(cls):
+    def _is_kernel_dump(cls):
         instance = cls._instance
         if not instance:
             raise Exception(MsgConst.NOT_CREATED_INSTANCE)
         return instance.config.level_ori == Const.LEVEL_L2
+
+    @classmethod
+    def _start_kernel_dump(cls):
+        instance = cls._get_instance()
+        is_graph_config = cls._is_graph_dump(instance.config)
+        instance.config.check_config_with_l2(is_graph_config)
+        if not is_graph_config:
+            if not instance.service:
+                instance.service = MindsporeService(instance.config)
+            instance.service.start()
+        else:
+            if _msprobe_c:
+                _msprobe_c._PrecisionDebugger().start()
+            if not instance.first_start:
+                get_api_register().restore_all_api()
+                handlers = TaskHandlerFactory.create(instance.config)
+                for handler in handlers:
+                    handler.handle()
+                if enable_dynamic_kbyk_dump:
+                    _set_init_iter(0)
+            if enable_dynamic_kbyk_dump:
+                is_valid_rank = (not instance.config.rank or Runtime.rank_id in instance.config.rank)
+                is_valid_step = (not instance.config.step or Runtime.step_count in instance.config.step)
+                if is_valid_rank and is_valid_step:
+                    _dump_start()

msprobe/mindspore/dump/dump_tool_factory.py

@@ -51,6 +51,8 @@ class DumpToolFactory:
         else:
             if len(config.data_mode) != 1 or config.data_mode[0] not in Const.GRAPH_DATA_MODE_LIST:
                 raise Exception("data_mode must be one of all, input, output.")
+        if config.level == Const.KERNEL:
+            return (KernelGraphDump(config), KernelKbykDump(config))
         tool = DumpToolFactory.tools.get(config.level)
         if not tool:
             raise Exception("Valid level is needed.")

msprobe/mindspore/dump/hook_cell/hook_cell.py

@@ -13,15 +13,16 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import threading
 from collections import defaultdict
 
 import mindspore as ms
 from mindspore import nn
 
 from msprobe.core.common.runtime import Runtime
+from msprobe.core.common.utils import ThreadSafe
 from msprobe.mindspore.common.utils import is_mindtorch, register_backward_hook_functions
 
-
 ms_version = ms.__version__
 
 
@@ -35,16 +36,17 @@ def get_cell_count(name):
 
 def __init__(self, hook_build_func) -> None:
     super(HOOKCell, self).__init__()
-    self.changed_status = False
     self.msprobe_input_kwargs = {}
-    if not HOOKCell.g_stop_hook:
-        HOOKCell.g_stop_hook = True
-        self.changed_status = True
+
+    self.tid = threading.get_ident()
+    self.stop_hook = HOOKCell.inner_stop_hook.get(self.tid, False)
+    if not self.stop_hook:
         self.forward_data_collected = False
 
         if not Runtime.is_running:
             return
         prefix = self.prefix_api_name if hasattr(self, "prefix_api_name") else ""
+        ThreadSafe.acquire()
         if callable(hook_build_func):
             hook_set = hook_build_func(prefix)
             if ms_version < "2.6.0" and not is_mindtorch():
@@ -59,21 +61,24 @@ def __init__(self, hook_build_func) -> None:
 
 # 重载call，加全局标志。
 def __call__(self, *args, **kwargs):
+    changed = False
+    if not self.stop_hook:
+        HOOKCell.inner_stop_hook[self.tid] = True
+        changed = True
     try:
         self.msprobe_input_kwargs = kwargs
         out = super(HOOKCell, self).__call__(*args, **kwargs)
     except Exception as e:
         raise e
     finally:
-        if self.changed_status:
-            self.changed_status = False
-            HOOKCell.g_stop_hook = False
+        if changed:
+            HOOKCell.inner_stop_hook[self.tid] = False
     return out
 
 
 hook_cell_dict = {
     "cell_count": defaultdict(int),
-    "g_stop_hook": False,
+    "inner_stop_hook": defaultdict(bool),
     "add_cell_count": staticmethod(add_cell_count),
     "get_cell_count": staticmethod(get_cell_count),
     "__init__": __init__,

msprobe/mindspore/dump/hook_cell/ms_hook_manager.py

@@ -13,9 +13,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import threading
+
 from mindspore.common.api import _no_grad
 from msprobe.core.common.const import Const
-from msprobe.core.common.utils import replace_last_occurrence
+from msprobe.core.common.utils import replace_last_occurrence, ThreadSafe
 from msprobe.core.data_dump.data_processor.base import ModuleBackwardInputs
 from msprobe.core.hook_manager import BaseHookManager, HookSet
 from msprobe.mindspore.common.utils import has_kwargs_in_forward_hook
@@ -78,11 +80,14 @@ class MindsproeHookManager(BaseHookManager):
         def backward_pre_hook(module, grad_input):
             if self.config.level != Const.LEVEL_L2:
                 return
-            if not self._should_execute_hook(hook_type, module, False):
+            tid = threading.get_ident()
+            if not self._should_execute_hook(hook_type, module, False, tid):
                 return
-            BaseHookManager.inner_switch = True
-            module_input = ModuleBackwardInputs(grad_input=grad_input)
-            self.data_collector.update_api_or_module_name(name)
-            self.data_collector.backward_input_data_collect(name, module, self._pid, module_input)
-            BaseHookManager.inner_switch = False
+
+            with ThreadSafe():
+                BaseHookManager.inner_switch[tid] = True
+                module_input = ModuleBackwardInputs(grad_input=grad_input)
+                self.data_collector.update_api_or_module_name(name)
+                self.data_collector.backward_input_data_collect(name, module, self._pid, module_input)
+                BaseHookManager.inner_switch[tid] = False
         return backward_pre_hook

msprobe/mindspore/dump/hook_cell/primitive_hooks.py

@@ -14,13 +14,16 @@
 # limitations under the License.
 
 import os
+import threading
 
 from mindspore import ops
 from mindspore.common.tensor import Tensor
-
-from msprobe.core.common.utils import Const, DumpException
-from msprobe.core.data_dump.data_processor.base import (ModuleBackwardInputs, ModuleBackwardOutputs,
-                                                        ModuleForwardInputsOutputs)
+from msprobe.core.common.utils import Const, DumpException, ThreadSafe
+from msprobe.core.data_dump.data_processor.base import (
+    ModuleBackwardInputs,
+    ModuleBackwardOutputs,
+    ModuleForwardInputsOutputs
+)
 from msprobe.core.hook_manager import BaseHookManager
 from msprobe.mindspore.common.log import logger
 
@@ -56,10 +59,13 @@ class PrimitiveHookService:
                 callable: 反向 hook 函数。
             """
 
+            @ThreadSafe.synchronized
             def backward_hook(grad):
+                tid = threading.get_ident()
+                BaseHookManager.inner_switch[tid] = True
+
                 captured_grads.extend(grad)
                 backward_primitive_name = f"{updated_primitive_name}{Const.SEP}{Const.BACKWARD}"
-                self.service_instance.inner_switch = True
                 try:
                     if hook_type == Const.INPUT:
                         self.service_instance.data_collector.update_api_or_module_name(backward_primitive_name)
@@ -78,7 +84,7 @@ class PrimitiveHookService:
                     logger.error(f"This is a primitive op {hook_type}_backward dump error: {exception}, "
                                  f"updated_primitive_name: {updated_primitive_name}")
                     raise DumpException(DumpException.BACKWARD_DATA_COLLECTION_ERROR) from exception
-                self.service_instance.inner_switch = False
+                BaseHookManager.inner_switch[tid] = False
 
             return backward_hook
 
@@ -137,9 +143,13 @@ class PrimitiveHookService:
                 return tuple(hooked_outputs)
             return out
 
+        @ThreadSafe.synchronized
         def pre_forward_hook(primitive_name, primitive_instance, args, kwargs):
+            tid = threading.get_ident()
+            BaseHookManager.inner_switch[tid] = True
+
+            self.service_instance.data_collector.update_api_or_module_name(primitive_name)
             module_input_output = ModuleForwardInputsOutputs(args=args, kwargs=kwargs, output=None)
-            self.service_instance.inner_switch = True
             try:
                 self.service_instance.data_collector.forward_input_data_collect(
                     primitive_name,
@@ -151,11 +161,15 @@ class PrimitiveHookService:
                 logger.error(f"This is a primitive op dump error during forward input data collection: {exception}, "
                              f"primitive_name: {primitive_name}")
                 raise DumpException(DumpException.FORWARD_DATA_COLLECTION_ERROR) from exception
-            self.service_instance.inner_switch = False
+            BaseHookManager.inner_switch[tid] = False
 
+        @ThreadSafe.synchronized
         def post_forward_hook(primitive_name, primitive_instance, args, kwargs, output):
+            tid = threading.get_ident()
+            BaseHookManager.inner_switch[tid] = True
+
+            self.service_instance.data_collector.update_api_or_module_name(primitive_name)
             module_input_output = ModuleForwardInputsOutputs(args=args, kwargs=kwargs, output=output)
-            self.service_instance.inner_switch = True
             try:
                 self.service_instance.data_collector.forward_output_data_collect(
                     primitive_name,
@@ -167,7 +181,7 @@ class PrimitiveHookService:
                 logger.error(f"This is a primitive op dump error during forward output data collection: {exception}, "
                              f"primitive_name: {primitive_name}")
                 raise DumpException(DumpException.FORWARD_DATA_COLLECTION_ERROR) from exception
-            self.service_instance.inner_switch = False
+            BaseHookManager.inner_switch[tid] = False
 
         def wrapped_primitive_call(instance_self, *args, **kwargs):
             """
@@ -185,7 +199,8 @@ class PrimitiveHookService:
             current_count = self.primitive_counters.get(primitive_name, 0)
             updated_primitive_name = f"{Const.PRIMITIVE_PREFIX}{Const.SEP}{primitive_name}{Const.SEP}{current_count}"
 
-            if not self.service_instance.primitive_switch or BaseHookManager.inner_switch:
+            tid = threading.get_ident()
+            if not self.service_instance.primitive_switch or BaseHookManager.inner_switch[tid]:
                 return origin_func(*args, **kwargs)
 
             captured_grads_input, captured_grads_output = [], []
@@ -198,8 +213,6 @@ class PrimitiveHookService:
                 raise DumpException(DumpException.INPUT_HOOK_ERROR) from exception
 
             forward_primitive_name = f"{updated_primitive_name}{Const.SEP}{Const.FORWARD}"
-            self.service_instance.data_collector.update_api_or_module_name(forward_primitive_name)
-
             pre_forward_hook(forward_primitive_name, instance_self, hooked_inputs, kwargs)
             try:
                 out = origin_func(*hooked_inputs, **kwargs)
@@ -220,6 +233,7 @@ class PrimitiveHookService:
 
         return wrapped_primitive_call
 
+    @ThreadSafe.synchronized
     def update_primitive_counters(self, primitive_name):
         if primitive_name not in self.primitive_counters:
             self.primitive_counters[primitive_name] = 0

msprobe/mindspore/dump/jit_dump.py

@@ -13,13 +13,14 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from collections import defaultdict
 import os
 import types
+from collections import defaultdict
 
 import mindspore
 from mindspore import nn
 from mindspore._c_expression import PyNativeExecutor_
+
 try:
     from mindspore.common.api import _MindsporeFunctionExecutor
 except ImportError:
@@ -27,19 +28,21 @@ except ImportError:
 
 from msprobe.core.common.log import logger
 from msprobe.core.common.const import Const
+from msprobe.core.common.utils import ThreadSafe
 from msprobe.core.common.runtime import Runtime
 from msprobe.core.data_dump.data_processor.base import ModuleForwardInputsOutputs, ModuleBackwardInputsOutputs
 from msprobe.mindspore.common.const import Const as MsConst
 from msprobe.mindspore.dump.hook_cell.api_register import get_api_register
 
-
 _api_register = get_api_register()
 
 
 def dump_jit(name, in_feat, out_feat, is_forward):
     pid = os.getpid()
     name = name if name else "JitFunction"
-    if JitDump.need_dump():
+    if not JitDump.need_dump():
+        return
+    with ThreadSafe():
         if is_forward:
             if name in JitDump.jit_count:
                 JitDump.jit_count[name] += 1

msprobe/mindspore/dump/kernel_kbyk_dump.py

@@ -39,12 +39,19 @@ class KernelKbykDump:
         common_set["input_output"] = 0
         common_set["kernels"] = []
         common_set["support_device"] = [0, 1, 2, 3, 4, 5, 6, 7]
-        e2e_set = {
-                    "enable": not config.async_dump,
-                    "trans_flag": True,
-                    "stat_calc_mode": config.stat_cal_mode,
-                    "device_stat_precision_mode": config.device_stat_precision_mode,
-                  }
+
+        if config.stat_cal_mode and config.device_stat_precision_mode:
+            e2e_set = {
+                        "enable": not config.async_dump,
+                        "trans_flag": True,
+                        "stat_calc_mode": config.stat_cal_mode,
+                        "device_stat_precision_mode": config.device_stat_precision_mode
+                    }
+        else:
+            e2e_set = {
+                        "enable": not config.async_dump,
+                        "trans_flag": True
+                    }
 
         if config.list:
             common_set["dump_mode"] = 1

msprobe/mindspore/dym_loader/hook_dynamic_loader.cpp

@@ -23,13 +23,14 @@
 
 namespace py = pybind11;
 
-HookDynamicLoader &HookDynamicLoader::GetInstance() 
+HookDynamicLoader &HookDynamicLoader::GetInstance()
 {
     static HookDynamicLoader instance;
     return instance;
 }
 
-bool HookDynamicLoader::LoadFunction(void *handle, const std::string &functionName) {
+bool HookDynamicLoader::LoadFunction(void *handle, const std::string &functionName)
+{
     void *func = dlsym(handle, functionName.c_str());
     if (!func) {
         MS_LOG(WARNING) << "Could not load function: " << functionName << ", error: " << dlerror();
@@ -83,7 +84,7 @@ bool HookDynamicLoader::LoadLibrary()
     return true;
 }
 
-bool HookDynamicLoader::UnloadLibrary() 
+bool HookDynamicLoader::UnloadLibrary()
 {
     std::lock_guard<std::mutex> lock(mutex_);
     if (!handle_) {
@@ -103,8 +104,8 @@ void *HookDynamicLoader::GetHooker(const std::string &funcName)
     std::lock_guard<std::mutex> lock(mutex_);
     auto iter = funcMap_.find(funcName);
     if (iter == funcMap_.end()) {
-      MS_LOG(WARNING) << "Function not found: " << funcName;
-      return nullptr;
+        MS_LOG(WARNING) << "Function not found: " << funcName;
+        return nullptr;
     }
     return iter->second;
 }

msprobe/mindspore/dym_loader/hook_dynamic_loader.h

@@ -1,5 +1,5 @@
-/**
- * Copyright 2024 Huawei Technologies Co., Ltd
+/*
+ * Copyright (C) 2024-2025. 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.

msprobe/mindspore/grad_probe/grad_analyzer.py

@@ -245,6 +245,8 @@ class CSVGenerator(Process):
         return ["Max", "Min", "Norm", "Shape"]
 
     def get_dist_header(self) -> List[str]:
+        if not self.bounds:
+            return []
         intervals = []
         for i, _ in enumerate(self.bounds):
             if i == 0:

msprobe/mindspore/mindspore_service.py

@@ -39,11 +39,11 @@ else:
     pijit_label = True
 
 
-class MindsporeService(BaseService):    
+class MindsporeService(BaseService):
     @property
     def _get_framework_type(self):
         return Const.MT_FRAMEWORK if is_mindtorch() else Const.MS_FRAMEWORK
-    
+
     @staticmethod
     def _get_current_rank():
         return get_rank_if_initialized()

msprobe/mindspore/monitor/common_func.py

@@ -16,7 +16,7 @@
 
 from mindspore import nn
 from mindspore import communication
-from msprobe.mindspore.monitor.utils import logger
+from msprobe.core.common.log import logger
 from msprobe.mindspore.common.utils import is_mindtorch
 if is_mindtorch():
     import torch

msprobe/mindspore/monitor/module_hook.py

@@ -28,11 +28,12 @@ from mindspore import nn, _no_grad
 from msprobe.core.common.log import logger
 from msprobe.core.common.const import MonitorConst, Const
 from msprobe.core.common.file_utils import load_json, save_json
+from msprobe.core.monitor.utils import validate_config, get_output_base_dir, get_target_output_dir
 from msprobe.core.monitor.anomaly_processor import AnomalyScanner, AnomalyDataFactory, AnomalyDataWriter
 from msprobe.mindspore.common.utils import is_mindtorch
 from msprobe.mindspore.monitor.common_func import is_valid_instance, get_parameters, get_submodules, get_rank
-from msprobe.mindspore.monitor.utils import get_summary_writer_tag_name, validate_config, step_accumulates_one, \
-    is_skip_step, get_metrics, get_target_output_dir
+from msprobe.mindspore.monitor.utils import get_summary_writer_tag_name, step_accumulates_one, is_skip_step, \
+    get_metrics
 from msprobe.mindspore.monitor.optimizer_collect import OptimizerMonFactory
 from msprobe.mindspore.monitor.data_writers import CSVWriterWithAD, BaseWriterWithAD, WriterInput
 from msprobe.mindspore.monitor.distributed.wrap_distributed import api_register, create_hooks, op_aggregate
@@ -250,7 +251,6 @@ class TrainerMon:
         self.has_collect_times = 0  # 重设采集计数器
         self.print_struct = self.config.get("print_struct", False)
         self.targets = self.config.get("targets", None)
-        self.is_select = self.config.get("is_select", False)
         self.module_rank_list = self.config.get("module_ranks", [])
         self.format = self.config.get('format', MonitorConst.CSV)  # only csv supported in mindspore
         self.eps = self.config.get('eps', 1e-8)