mindstudio-probe 1.0.1__py3-none-any.whl → 1.0.4__py3-none-any.whl

msprobe/mindspore/dump/hook_cell/wrap_api.py

@@ -0,0 +1,113 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+# Copyright (C) 2024-2024. 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 os
+
+from mindspore import Tensor, ops, mint
+from mindspore.mint.nn import functional
+from mindspore.common._stub_tensor import StubTensor
+
+from msprobe.mindspore.dump.hook_cell.hook_cell import HOOKCell
+from msprobe.core.common.const import Const
+from msprobe.mindspore.common.const import Const as MsConst
+from msprobe.core.common.file_utils import load_yaml
+
+
+cur_path = os.path.dirname(os.path.realpath(__file__))
+yaml_path = os.path.join(cur_path, MsConst.SUPPORTED_API_LIST_FILE)
+
+
+class HOOKTensor(object):
+    pass
+
+
+class HOOKStubTensor(object):
+    pass
+
+
+class HOOKFunctionalOP(object):
+    pass
+
+
+class HOOKMintOP(object):
+    pass
+
+
+class HOOKMintNNFunctionalOP(object):
+    pass
+
+
+class ApiTemplate(HOOKCell):
+    def __init__(self, api_name, api_dict, prefix, hook):
+        self.api_name = api_name
+        self.api_func = api_dict[api_name]
+        self.prefix_api_name = prefix + str(api_name.split(Const.SEP)[-1]) + Const.SEP
+        super().__init__(hook)
+
+    def construct(self, *args, **kwargs):
+        if self.api_name.startswith(MsConst.DROPOUT_API_NAME_PREFIX):
+            return args[0] if args else kwargs.get(Const.INPUT)
+        return self.api_func(*args, **kwargs)
+
+
+class WrapApiName:
+    def __init__(self, tensor_api_names, stub_tensor_api_names, ops_api_names, mint_api_names, mint_nn_func_api_names):
+        self.tensor_api_names = tensor_api_names
+        self.stub_tensor_api_names = stub_tensor_api_names
+        self.ops_api_names = ops_api_names
+        self.mint_api_names = mint_api_names
+        self.mint_nn_func_api_names = mint_nn_func_api_names
+
+
+def get_wrap_api_list():
+    api_list = load_yaml(yaml_path)
+    tensor_api = api_list.get(MsConst.SUPPORTED_TENSOR_LIST_KEY)
+    ops_api = api_list.get(MsConst.SUPPORTED_OPS_LIST_KEY)
+    mint_api = api_list.get(MsConst.SUPPORTED_MINT_LIST_KEY)
+    mint_nn_func_api = api_list.get(MsConst.SUPPORTED__MINT_NN_FUNC_LIST_KEY)
+    wrap_api_name = WrapApiName(set(tensor_api) & set(dir(Tensor)),
+                                set(tensor_api) & set(dir(StubTensor)),
+                                set(ops_api) & set(dir(ops)),
+                                set(mint_api) & set(dir(mint)),
+                                set(mint_nn_func_api) & set(dir(functional)))
+    return wrap_api_name
+
+
+def wrap_api_func(api_name, api_dict, prefix, hook):
+    def api_function(*args, **kwargs):
+        return ApiTemplate(api_name, api_dict, prefix, hook)(*args, **kwargs)
+    return api_function
+
+
+def wrap_api_func_and_bind(api_list, api_dict, prefix, hook, hook_class):
+    for api_name in api_list:
+        if callable(api_dict[api_name]):
+            setattr(hook_class, Const.ATTR_NAME_PREFIX + api_name, wrap_api_func(api_name, api_dict, prefix, hook))
+
+
+def setup_hooks(hook):
+    wrap_api_name = get_wrap_api_list()
+    wrap_api_func_and_bind(wrap_api_name.tensor_api_names, {f: getattr(Tensor, f) for f in dir(Tensor)},
+                           MsConst.TENSOR_DATA_PREFIX, hook, HOOKTensor)
+    wrap_api_func_and_bind(wrap_api_name.stub_tensor_api_names, {f: getattr(StubTensor, f) for f in dir(StubTensor)},
+                           MsConst.STUB_TENSOR_DATA_PREFIX, hook, HOOKStubTensor)
+    wrap_api_func_and_bind(wrap_api_name.ops_api_names, {f: getattr(ops, f) for f in dir(ops)},
+                           MsConst.OPS_DATA_PREFIX, hook, HOOKFunctionalOP)
+    wrap_api_func_and_bind(wrap_api_name.mint_api_names, {f: getattr(mint, f) for f in dir(mint)},
+                           MsConst.MINT_DATA_PREFIX, hook, HOOKMintOP)
+    wrap_api_func_and_bind(wrap_api_name.mint_nn_func_api_names, {f: getattr(functional, f) for f in dir(functional)},
+                           MsConst.MINT_NN_FUNC_DATA_PREFIX, hook, HOOKMintNNFunctionalOP)

msprobe/mindspore/dump/jit_dump.py

@@ -0,0 +1,72 @@
+import os
+
+from mindspore import Tensor
+from mindspore.common.api import _MindsporeFunctionExecutor
+from mindspore._c_expression import PyNativeExecutor_
+
+from msprobe.mindspore.dump.hook_cell.api_registry import api_register
+from msprobe.core.data_dump.data_processor.base import ModuleForwardInputsOutputs
+from msprobe.core.common.const import Const
+
+
+def dump_jit(name, in_feat, out_feat, is_forward):
+    pid = os.getpid()
+    ori_args = str(name)
+    index = ori_args.find("<")
+    if index != 0 and index != -1:
+        result = ori_args[0:index]
+    else:
+        result = "JitFunction"
+    if is_forward:
+        name_template = "Jit." + result + ".forward"
+    else:
+        name_template = "Jit." + result + ".backward"
+    if JitDump.need_dump():
+        JitDump.data_collector.update_api_or_module_name(name_template)
+        module_input_output = ModuleForwardInputsOutputs(args=in_feat, kwargs={}, output=out_feat)
+        JitDump.data_collector.forward_data_collect(name_template, {}, pid, module_input_output)
+
+
+class JitDump(_MindsporeFunctionExecutor):
+    dump_config = None
+    jit_enable = False
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._executor = PyNativeExecutor_.get_instance()
+
+    def __call__(self, *args, **kwargs):
+        api_register.api_set_ori_func()
+        out = super().__call__(*args, **kwargs)
+        if isinstance(args[0], Tensor):
+            dump_jit({}, args, out, True)
+        else:
+            dump_jit(args[0], args[1:], out, True)
+        JitDump.jit_enable = True
+        api_register.api_set_hook_func()
+        return out
+
+    @classmethod
+    def set_config(cls, value):
+        cls.dump_config = value
+
+    @classmethod
+    def set_data_collector(cls, value):
+        cls.data_collector = value
+
+    @classmethod
+    def need_dump(cls):
+        if cls.dump_config.task != Const.TENSOR and cls.dump_config.task != Const.STATISTICS:
+            return False
+        if not cls.data_collector or cls.data_collector.data_processor.is_terminated:
+            return False
+        return True
+
+    def grad(self, obj, grad, weights, grad_position, *args,  **kwargs):
+        if JitDump.jit_enable:
+            api_register.api_set_ori_func()
+        output = self._executor.grad(grad, obj, weights, grad_position, *args, *(kwargs.values()))
+        if JitDump.jit_enable:
+            dump_jit(obj, args, None, False)
+            api_register.api_set_hook_func()
+        return output

msprobe/mindspore/dump/kernel_graph_dump.py

@@ -1,60 +1,59 @@
-import os
-import json
-from msprobe.core.common.utils import make_dump_path_if_not_exists
-from msprobe.mindspore.debugger.debugger_config import DebuggerConfig
-from msprobe.core.common.log import logger
-from msprobe.core.common.file_check import FileOpen
-
-
-class KernelGraphDump:
-    def __init__(self, config: DebuggerConfig):
-        self.dump_json = dict()
-        self.dump_json["common_dump_settings"] = dict()
-        self.dump_json["common_dump_settings"]["dump_mode"] = 0
-        self.dump_json["common_dump_settings"]["path"] = ""
-        self.dump_json["common_dump_settings"]["net_name"] = "Net"
-        self.dump_json["common_dump_settings"]["iteration"] = "all"
-        self.dump_json["common_dump_settings"]["saved_data"] = "statistic"
-        self.dump_json["common_dump_settings"]["input_output"] = 0
-        self.dump_json["common_dump_settings"]["kernels"] = []
-        self.dump_json["common_dump_settings"]["support_device"] = [0, 1, 2, 3, 4, 5, 6, 7]
-        self.dump_json["common_dump_settings"]["op_debug_mode"] = 0
-        self.dump_json["common_dump_settings"]["file_format"] = "npy"
-
-        if len(config.list) > 0:
-            self.dump_json["common_dump_settings"]["dump_mode"] = 1
-            self.dump_json["common_dump_settings"]["kernels"] = config.list
-        self.dump_json["common_dump_settings"]["path"] = config.dump_path
-        if len(config.step) > 0:
-            step_str = ""
-            for s in config.step:
-                step_str += (str(s) + '|')
-            self.dump_json["common_dump_settings"]["iteration"] = step_str[:-1]
-        if len(config.rank) > 0:
-            self.dump_json["common_dump_settings"]["support_device"] = config.rank
-        if config.task == "tensor":
-            self.dump_json["common_dump_settings"]["saved_data"] = "tensor"
-            self.dump_json["common_dump_settings"]["file_format"] = config.file_format
-        if len(config.data_mode) == 1:
-            if config.data_mode[0] == "input":
-                self.dump_json["common_dump_settings"]["input_output"] = 1
-            if config.data_mode[0] == "output":
-                self.dump_json["common_dump_settings"]["input_output"] = 2
-
-    def handle(self):
-        if os.getenv("GRAPH_OP_RUN") == "1":
-            raise Exception("Must run in graph mode, not kbk mode")
-        json_path = self.dump_json["common_dump_settings"]["path"]
-        make_dump_path_if_not_exists(json_path)
-        json_path = os.path.join(json_path, "kernel_graph_dump.json")
-        with FileOpen(json_path, 'w') as f:
-            json.dump(self.dump_json, f)
-        logger.info(json_path + " has been created.")
-        os.environ["MINDSPORE_DUMP_CONFIG"] = json_path
-        if self.dump_json["common_dump_settings"]["dump_mode"] == 0:
-            if self.dump_json["common_dump_settings"]["iteration"] != "all" or \
-               len(self.dump_json["common_dump_settings"]["kernels"]) == 0:
-                os.environ["MS_ACL_DUMP_CFG_PATH"] = json_path
-        else:
-            if "MS_ACL_DUMP_CFG_PATH" in os.environ:
-                del os.environ["MS_ACL_DUMP_CFG_PATH"]
+import os
+import json
+from msprobe.mindspore.debugger.debugger_config import DebuggerConfig
+from msprobe.mindspore.common.log import logger
+from msprobe.core.common.file_utils import FileOpen, create_directory
+
+
+class KernelGraphDump:
+    def __init__(self, config: DebuggerConfig):
+        self.dump_json = dict()
+        self.dump_json["common_dump_settings"] = dict()
+        self.dump_json["common_dump_settings"]["dump_mode"] = 0
+        self.dump_json["common_dump_settings"]["path"] = ""
+        self.dump_json["common_dump_settings"]["net_name"] = "Net"
+        self.dump_json["common_dump_settings"]["iteration"] = "all"
+        self.dump_json["common_dump_settings"]["saved_data"] = "statistic"
+        self.dump_json["common_dump_settings"]["input_output"] = 0
+        self.dump_json["common_dump_settings"]["kernels"] = []
+        self.dump_json["common_dump_settings"]["support_device"] = [0, 1, 2, 3, 4, 5, 6, 7]
+        self.dump_json["common_dump_settings"]["op_debug_mode"] = 0
+        self.dump_json["common_dump_settings"]["file_format"] = "npy"
+
+        if len(config.list) > 0:
+            self.dump_json["common_dump_settings"]["dump_mode"] = 1
+            self.dump_json["common_dump_settings"]["kernels"] = config.list
+        self.dump_json["common_dump_settings"]["path"] = config.dump_path
+        if len(config.step) > 0:
+            step_str = ""
+            for s in config.step:
+                step_str += (str(s) + '|')
+            self.dump_json["common_dump_settings"]["iteration"] = step_str[:-1]
+        if len(config.rank) > 0:
+            self.dump_json["common_dump_settings"]["support_device"] = config.rank
+        if config.task == "tensor":
+            self.dump_json["common_dump_settings"]["saved_data"] = "tensor"
+            self.dump_json["common_dump_settings"]["file_format"] = config.file_format
+        if len(config.data_mode) == 1:
+            if config.data_mode[0] == "input":
+                self.dump_json["common_dump_settings"]["input_output"] = 1
+            if config.data_mode[0] == "output":
+                self.dump_json["common_dump_settings"]["input_output"] = 2
+
+    def handle(self):
+        if os.getenv("GRAPH_OP_RUN") == "1":
+            raise Exception("Must run in graph mode, not kbk mode")
+        json_path = self.dump_json["common_dump_settings"]["path"]
+        create_directory(json_path)
+        json_path = os.path.join(json_path, "kernel_graph_dump.json")
+        with FileOpen(json_path, 'w') as f:
+            json.dump(self.dump_json, f)
+        logger.info(json_path + " has been created.")
+        os.environ["MINDSPORE_DUMP_CONFIG"] = json_path
+        if self.dump_json["common_dump_settings"]["dump_mode"] == 0:
+            if self.dump_json["common_dump_settings"]["iteration"] != "all" or \
+               len(self.dump_json["common_dump_settings"]["kernels"]) == 0:
+                os.environ["MS_ACL_DUMP_CFG_PATH"] = json_path
+        else:
+            if "MS_ACL_DUMP_CFG_PATH" in os.environ:
+                del os.environ["MS_ACL_DUMP_CFG_PATH"]

msprobe/mindspore/dump/kernel_kbyk_dump.py

@@ -0,0 +1,64 @@
+import os
+import json
+
+from msprobe.mindspore.debugger.debugger_config import DebuggerConfig
+from msprobe.mindspore.common.log import logger
+from msprobe.core.common.file_utils import FileOpen, create_directory
+from msprobe.core.common.const import Const
+
+
+class KernelKbykDump:
+    COMMON_SETTINGS = "common_dump_settings"
+    E2E_SETTINGS = "e2e_dump_settings"
+
+    def __init__(self, config: DebuggerConfig):
+        self.dump_json = dict()
+        common_set = dict()
+        e2e_set = dict()
+
+        common_set = dict()
+        common_set["dump_mode"] = 0
+        common_set["path"] = ""
+        common_set["net_name"] = "Net"
+        common_set["iteration"] = "all"
+        common_set["saved_data"] = "statistic"
+        common_set["input_output"] = 0
+        common_set["kernels"] = []
+        common_set["support_device"] = [0, 1, 2, 3, 4, 5, 6, 7]
+        e2e_set = dict()
+        e2e_set["enable"] = True
+        e2e_set["trans_flag"] = True
+
+        if config.list:
+            common_set["dump_mode"] = 1
+            common_set["kernels"] = config.list
+        common_set["path"] = config.dump_path
+        if config.step:
+            step_str = ""
+            for s in config.step:
+                step_str += (str(s) + '|')
+            common_set["iteration"] = step_str[:-1]
+        if config.rank:
+            common_set["support_device"] = config.rank
+        if config.task == Const.TENSOR:
+            common_set["saved_data"] = Const.TENSOR
+        if len(config.data_mode) == 1:
+            if config.data_mode[0] == Const.INPUT:
+                common_set["input_output"] = 1
+            if config.data_mode[0] == Const.OUTPUT:
+                common_set["input_output"] = 2
+
+        self.dump_json[KernelKbykDump.COMMON_SETTINGS] = common_set
+        self.dump_json[KernelKbykDump.E2E_SETTINGS] = e2e_set
+
+    def handle(self):
+        json_path = self.dump_json[KernelKbykDump.COMMON_SETTINGS]["path"]
+        create_directory(json_path)
+        json_path = os.path.join(json_path, "kernel_kbyk_dump.json")
+        with FileOpen(json_path, 'w') as f:
+            json.dump(self.dump_json, f)
+        logger.info(json_path + " has been created.")
+
+        os.environ["MINDSPORE_DUMP_CONFIG"] = json_path
+        if "MS_ACL_DUMP_CFG_PATH" in os.environ:
+            del os.environ["MS_ACL_DUMP_CFG_PATH"]

msprobe/mindspore/free_benchmark/api_pynative_self_check.py

@@ -0,0 +1,116 @@
+import os
+import inspect
+import importlib
+
+import mindspore as ms
+from mindspore.communication import comm_func
+
+from msprobe.core.common.file_utils import load_yaml, check_path_length
+from msprobe.core.common.const import Const
+from msprobe.mindspore.common.const import Const as MsConst
+from msprobe.mindspore.common.const import FreeBenchmarkConst
+from msprobe.mindspore.free_benchmark.common.config import Config
+from msprobe.mindspore.common.log import logger
+from msprobe.mindspore.debugger.debugger_config import DebuggerConfig
+from msprobe.mindspore.free_benchmark.decorator.decorator_factory import decorate_forward_function
+
+
+class ApiPyNativeSelFCheck:
+    def __init__(self, config: DebuggerConfig):
+        Config.is_enable = True
+        Config.handler_type = config.handler_type
+        Config.pert_type = config.pert_type
+        Config.stage = config.stage
+        Config.dump_level = config.dump_level
+        Config.steps = config.step
+        Config.ranks = config.rank
+        Config.dump_path = os.path.join(config.dump_path, "free_benchmark.csv")
+        check_path_length(Config.dump_path)
+
+        self.api_list = config.list
+        all_api = get_supported_ops()
+        if not self.api_list:
+            self.api_list = all_api
+        else:
+            self.api_list = set(self.api_list) & all_api
+
+    def handle(self):
+        for api_name in self.api_list:
+            hijack(api_name)
+
+
+def get_supported_ops():
+    supported_ops = []
+    cur_path = os.path.dirname(os.path.realpath(__file__))
+    yaml_path = os.path.join(cur_path, "data", "support_wrap_ops.yaml")
+
+    yaml_data = load_yaml(yaml_path)
+    for k, v in FreeBenchmarkConst.API_PREFIX_DICT.items():
+        ops = yaml_data.get(k)
+        if ops:
+            ops = [v + i for i in ops]
+            supported_ops += ops
+
+    _all_functional_ops = []
+    ms_ops = dir(ms.ops)
+    ms_ops = [MsConst.OPS_PREFIX + i for i in ms_ops]
+    _all_functional_ops += ms_ops
+
+    ms_tensor = dir(ms.Tensor)
+    ms_tensor = [MsConst.Tensor_PREFIX + i for i in ms_tensor]
+    _all_functional_ops += ms_tensor
+
+    ms_mint = dir(ms.mint)
+    ms_mint = [MsConst.MINT_PREFIX + i for i in ms_mint]
+    _all_functional_ops += ms_mint
+
+    ms_mint_nn_func = dir(ms.mint.nn.functional)
+    ms_mint_nn_func = [MsConst.MINT_NN_FUNC_PREFIX + i for i in ms_mint_nn_func]
+    _all_functional_ops += ms_mint_nn_func
+
+    ms_communication = dir(comm_func)
+    ms_communication = [MsConst.COMM_PREFIX + i for i in ms_communication]
+    _all_functional_ops += ms_communication
+
+    return set(supported_ops) & set(_all_functional_ops)
+
+
+def get_decorate_func():
+    return decorate_forward_function
+
+
+def is_func_support_decorate(orig_func):
+    return not inspect.isclass(orig_func) and callable(orig_func)
+
+
+def get_wrapper_obj(orig_func, api_name):
+    if is_func_support_decorate(orig_func):
+        wrapped_obj = get_decorate_func()(orig_func, api_name)
+    else:
+        wrapped_obj = orig_func
+    return wrapped_obj
+
+
+def get_module(api_name):
+    func_name_list = api_name.split(Const.SEP)
+    func_name = func_name_list[-1]
+    module_obj = importlib.import_module(func_name_list[0])
+    for i, module_name in enumerate(func_name_list[1:-1]):
+        if not hasattr(module_obj, module_name):
+            importlib.import_module(f"{Const.SEP.join(func_name_list[:i+2])}")
+        module_obj = getattr(module_obj, module_name)
+    orig_func = getattr(module_obj, func_name)
+
+    return module_obj, orig_func
+
+
+def hijack(api_name):
+    if not api_name.strip():
+        return
+    try:
+        func_name = api_name.split(Const.SEP)[-1]
+        module_obj, origin_func = get_module(api_name)
+        wrapped_obj = get_wrapper_obj(origin_func, api_name)
+        setattr(module_obj, func_name, wrapped_obj)
+    except Exception as e:
+        logger.error(f"Failed decorator {api_name}: {e}")

msprobe/mindspore/free_benchmark/common/config.py

@@ -0,0 +1,12 @@
+from msprobe.mindspore.common.const import FreeBenchmarkConst
+
+
+class Config:
+    is_enable: bool = False
+    handler_type = FreeBenchmarkConst.DEFAULT_HANDLER_TYPE
+    pert_type = FreeBenchmarkConst.DEFAULT_PERT_TYPE
+    stage = FreeBenchmarkConst.DEFAULT_STAGE
+    dump_level = FreeBenchmarkConst.DEFAULT_DUMP_LEVEL
+    steps: list = []
+    ranks: list = []
+    dump_path: str = ""

msprobe/mindspore/free_benchmark/common/handler_params.py

@@ -0,0 +1,17 @@
+from typing import Optional, Any, Tuple, Dict, Callable
+
+
+class HandlerParams:
+    """
+    参数结合体
+
+    """
+    args: Optional[Tuple] = None
+    kwargs: Optional[Dict] = None
+    index: Optional[int] = None
+    original_result: Optional[Any] = None
+    fuzzed_result: Optional[Any] = None
+    is_consistent: Optional[bool] = True
+    save_flag: Optional[bool] = True
+    fuzzed_value: Optional[Any] = None
+    original_func: Optional[Callable] = None

msprobe/mindspore/free_benchmark/common/utils.py

@@ -0,0 +1,71 @@
+from typing import Any
+from typing import Optional
+from dataclasses import dataclass
+
+import mindspore as ms
+from mindspore import Tensor
+
+from msprobe.mindspore.runtime import Runtime
+from msprobe.mindspore.common.const import FreeBenchmarkConst
+from .config import Config
+from .handler_params import HandlerParams
+
+
+class Tools:
+
+    @staticmethod
+    def get_first_tensor_dtype(tensor_seq: Any):
+        if isinstance(tensor_seq, Tensor):
+            return tensor_seq.dtype
+        if isinstance(tensor_seq, (list, tuple)):
+            for i in tensor_seq:
+                if isinstance(i, Tensor):
+                    return i.dtype
+        raise Exception("The sequence does not contain tensors.")
+
+    @staticmethod
+    def get_default_error_threshold(dtype):
+        if Config.pert_type == FreeBenchmarkConst.NO_CHANGE:
+            return FreeBenchmarkConst.NO_CHANGE_ERROR_THRESHOLD
+        return FreeBenchmarkConst.ERROR_THRESHOLD.get(dtype, FreeBenchmarkConst.ERROR_THRESHOLD.get(ms.float32))
+
+
+@dataclass
+class UnequalRow:
+    rank: Optional[int] = None
+    pert_type: Optional[str] = None
+    stage: Optional[str] = None
+    step: Optional[int] = None
+    api_name: Optional[str] = None
+    max_rel: Optional[float] = None
+    dtype: Optional[str] = None
+    shape: Optional[str] = None
+    output_index: Optional[int] = None
+
+
+def make_unequal_row(
+    api_name: str,
+    params: HandlerParams,
+    ratio: float = None,
+    index: int = None,
+):
+    row = UnequalRow(
+        api_name=api_name,
+        pert_type=Config.pert_type,
+        output_index=index,
+        stage=Config.stage,
+        step=Runtime.step_count
+    )
+    if isinstance(ratio, float):
+        row.max_rel = ratio - 1
+    original_tensor = params.original_result
+    fuzzed_tensor = params.fuzzed_result
+    if index is not None:
+        original_tensor = original_tensor[index]
+        fuzzed_tensor = fuzzed_tensor[index]
+        row.output_index = index
+    if isinstance(original_tensor, Tensor):
+        row.dtype = original_tensor.dtype
+        row.shape = original_tensor.shape
+    row.rank = Runtime.rank_id if Runtime.rank_id != -1 else None
+    return row