mindspore 2.1.0__cp38-cp38-manylinux1_x86_64.whl → 2.2.11__cp38-cp38-manylinux1_x86_64.whl

{mindspore-2.1.0.dist-info → mindspore-2.2.11.dist-info}/entry_points.txt

@@ -1,3 +1,2 @@
 [console_scripts]
 cache_admin = mindspore.dataset.engine.cache_admin:main
-

mindspore/_akg/akg/tvm/contrib/debugger/__init__.py

@@ -1,16 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you 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.

mindspore/_akg/akg/tvm/contrib/debugger/debug_result.py

@@ -1,274 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you 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.
-"""Graph debug results dumping class."""
-import collections
-import json
-import os
-import numpy as np
-import tvm
-
-GRAPH_DUMP_FILE_NAME = '_tvmdbg_graph_dump.json'
-CHROME_TRACE_FILE_NAME = "_tvmdbg_execution_trace.json"
-
-ChromeTraceEvent = collections.namedtuple(
-    'ChromeTraceEvent',
-    ['ts', 'tid', 'pid', 'name', 'ph']
-)
-
-
-class DebugResult(object):
-    """Graph debug data module.
-
-    Data dump module manage all the debug data formatting.
-    Output data and input graphs are formatted and dumped to file.
-    Frontend read these data and graph for visualization.
-
-    Parameters
-    ----------
-    graph_json : str
-        The graph to be deployed in json format output by nnvm graph. Each operator (tvm_op)
-        in the graph will have a one to one mapping with the symbol in libmod which is used
-        to construct a "PackedFunc" .
-
-    dump_path : str
-        Output data path is read/provided from frontend
-    """
-
-    def __init__(self, graph_json, dump_path):
-        self._dump_path = dump_path
-        self._output_tensor_list = []
-        self._time_list = []
-        self._parse_graph(graph_json)
-        # dump the json information
-        self.dump_graph_json(graph_json)
-
-    def _parse_graph(self, graph_json):
-        """Parse and extract the NNVM graph and update the nodes, shapes and dltype.
-
-        Parameters
-        ----------
-        graph_json : str or graph class
-           The graph to be deployed in json format output by nnvm graph.
-        """
-        json_obj = json.loads(graph_json)
-        self._nodes_list = json_obj['nodes']
-        self._shapes_list = json_obj['attrs']['shape']
-        self._dtype_list = json_obj['attrs']['dltype']
-        self._update_graph_json()
-
-    def _update_graph_json(self):
-        """update the nodes_list with name, shape and data type,
-        for temporarily storing the output.
-        """
-
-        nodes_len = len(self._nodes_list)
-        for i in range(nodes_len):
-            node = self._nodes_list[i]
-            input_list = []
-            for input_node in node['inputs']:
-                input_list.append(self._nodes_list[input_node[0]]['name'])
-            node['inputs'] = input_list
-            dtype = str("type: " + self._dtype_list[1][i])
-            if 'attrs' not in node:
-                node['attrs'] = {}
-                node['op'] = "param"
-            else:
-                node['op'] = node['attrs']['func_name']
-            node['attrs'].update({"T": dtype})
-            node['shape'] = self._shapes_list[1][i]
-
-    def _cleanup_tensors(self):
-        """Remove the tensor dump file (graph wont be removed)
-        """
-        for filename in os.listdir(self._dump_path):
-            if os.path.isfile(filename) and not filename.endswith(".json"):
-                os.remove(filename)
-
-    def get_graph_nodes(self):
-        """Return the nodes list
-        """
-        return self._nodes_list
-
-    def get_graph_node_shapes(self):
-        """Return the nodes shapes list
-        """
-        return self._shapes_list
-
-    def get_graph_node_output_num(self, node):
-        """Return the number of outputs of a node
-        """
-        return 1 if node['op'] == 'param' else int(node['attrs']['num_outputs'])
-
-    def get_graph_node_dtypes(self):
-        """Return the nodes dtype list
-        """
-        return self._dtype_list
-
-    def get_output_tensors(self):
-        """Dump the outputs to a temporary folder, the tensors are in numpy format
-        """
-        eid = 0
-        order = 0
-        output_tensors = {}
-        for node, time in zip(self._nodes_list, self._time_list):
-            num_outputs = self.get_graph_node_output_num(node)
-            for j in range(num_outputs):
-                order += time[0]
-                key = node['name'] + "_" + str(j)
-                output_tensors[key] = self._output_tensor_list[eid]
-                eid += 1
-        return output_tensors
-
-    def dump_output_tensor(self):
-        """Dump the outputs to a temporary folder, the tensors are in numpy format
-        """
-        #cleanup existing tensors before dumping
-        self._cleanup_tensors()
-        eid = 0
-        order = 0
-        output_tensors = {}
-        for node, time in zip(self._nodes_list, self._time_list):
-            num_outputs = self.get_graph_node_output_num(node)
-            for j in range(num_outputs):
-                order += time[0]
-                key = node['name'] + "_" + str(j) + "__" + str(order)
-                output_tensors[key] = self._output_tensor_list[eid]
-                eid += 1
-
-        with open(os.path.join(self._dump_path, "output_tensors.params"), "wb") as param_f:
-            param_f.write(save_tensors(output_tensors))
-
-    def dump_chrome_trace(self):
-        """Dump the trace to the Chrome trace.json format.
-        """
-        def s_to_us(t):
-            return t * 10 ** 6
-
-        starting_times = np.zeros(len(self._time_list) + 1)
-        starting_times[1:] = np.cumsum([times[0] for times in self._time_list])
-
-        def node_to_events(node, times, starting_time):
-            return [
-                ChromeTraceEvent(
-                    ts=s_to_us(starting_time),
-                    tid=1,
-                    pid=1,
-                    ph='B',
-                    name=node['name'],
-                ),
-                ChromeTraceEvent(
-                    # Use start + duration instead of end to ensure precise timings.
-                    ts=s_to_us(times[0] + starting_time),
-                    tid=1,
-                    pid=1,
-                    ph='E',
-                    name=node['name'],
-                ),
-            ]
-        events = [
-            e for (node, times, starting_time) in zip(
-                self._nodes_list, self._time_list, starting_times)
-            for e in node_to_events(node, times, starting_time)]
-        result = dict(
-            displayTimeUnit='ns',
-            traceEvents=[e._asdict() for e in events]
-        )
-
-        with open(os.path.join(self._dump_path, CHROME_TRACE_FILE_NAME), "w") as trace_f:
-            json.dump(result, trace_f)
-
-    def dump_graph_json(self, graph):
-        """Dump json formatted graph.
-
-        Parameters
-        ----------
-        graph : json format
-            json formatted NNVM graph contain list of each node's
-            name, shape and type.
-        """
-        graph_dump_file_name = GRAPH_DUMP_FILE_NAME
-        with open(os.path.join(self._dump_path, graph_dump_file_name), 'w') as outfile:
-            json.dump(graph, outfile, indent=4, sort_keys=False)
-
-    def display_debug_result(self, sort_by_time=True):
-        """Displays the debugger result"
-        """
-        header = ["Node Name", "Ops", "Time(us)", "Time(%)", "Shape", "Inputs", "Outputs"]
-        lines = ["---------", "---", "--------", "-------", "-----", "------", "-------"]
-        eid = 0
-        data = []
-        total_time = sum(time[0] for time in self._time_list)
-        for node, time in zip(self._nodes_list, self._time_list):
-            num_outputs = self.get_graph_node_output_num(node)
-            for j in range(num_outputs):
-                op = node['op']
-                if node['op'] == 'param':
-                    eid += 1
-                    continue
-                name = node['name']
-                shape = str(self._output_tensor_list[eid].shape)
-                time_us = round(time[0] * 1000000, 3)
-                time_percent = round(((time[0] / total_time) * 100), 3)
-                inputs = str(node['attrs']['num_inputs'])
-                outputs = str(node['attrs']['num_outputs'])
-                node_data = [name, op, time_us, time_percent, shape, inputs, outputs]
-                data.append(node_data)
-                eid += 1
-
-        if sort_by_time:
-            # Sort on the basis of execution time. Prints the most expensive ops in the start.
-            data = sorted(data, key=lambda x: x[2], reverse=True)
-            # Insert a row for total time at the end.
-            rounded_total_time = round(total_time * 1000000, 3)
-            data.append(["Total_time", "-", rounded_total_time, "-", "-", "-", "-", "-"])
-
-        fmt = ""
-        for i, _ in enumerate(header):
-            max_len = len(header[i])
-            for j, _ in enumerate(data):
-                item_len = len(str(data[j][i]))
-                if item_len > max_len:
-                    max_len = item_len
-            fmt = fmt + "{:<" + str(max_len + 2) + "}"
-        print(fmt.format(*header))
-        print(fmt.format(*lines))
-        for row in data:
-            print(fmt.format(*row))
-
-def save_tensors(params):
-    """Save parameter dictionary to binary bytes.
-
-    The result binary bytes can be loaded by the
-    GraphModule with API "load_params".
-
-    Parameters
-    ----------
-    params : dict of str to NDArray
-        The parameter dictionary.
-
-    Returns
-    -------
-    param_bytes: bytearray
-        Serialized parameters.
-    """
-    _save_tensors = tvm.get_global_func("_save_param_dict")
-
-    args = []
-    for k, v in params.items():
-        args.append(k)
-        args.append(tvm.nd.array(v))
-    return _save_tensors(*args)

mindspore/_akg/akg/tvm/contrib/debugger/debug_runtime.py

@@ -1,259 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you 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.
-"""Graph debug runtime executes TVM debug packed functions."""
-
-import os
-import tempfile
-import shutil
-from tvm._ffi.base import string_types
-from tvm._ffi.function import get_global_func
-from tvm.contrib import graph_runtime
-from tvm.ndarray import array
-from tvm.rpc import base as rpc_base
-from . import debug_result
-
-_DUMP_ROOT_PREFIX = "tvmdbg_"
-_DUMP_PATH_PREFIX = "_tvmdbg_"
-
-
-def create(graph_json_str, libmod, ctx, dump_root=None):
-    """Create a runtime executor module given a graph and module.
-
-    Parameters
-    ----------
-    graph_json_str : str or graph class
-        The graph to be deployed in json format output by nnvm graph.
-        The graph can only contain one operator(tvm_op) that
-        points to the name of PackedFunc in the libmod.
-
-    libmod : tvm.Module
-        The module of the corresponding function.
-
-    ctx : TVMContext
-        The context to deploy the module, can be local or remote.
-
-    dump_root : str
-        To select which folder the outputs should be kept.
-        None will make a temp folder in /tmp/tvmdbg<rand_string> and does the dumping
-    Returns
-    -------
-    graph_module : GraphModuleDebug
-        Debug Runtime graph module that can be used to execute the graph.
-    """
-    if not isinstance(graph_json_str, string_types):
-        try:
-            graph_json_str = graph_json_str._tvm_graph_json()
-        except AttributeError:
-            raise ValueError("Type %s is not supported" % type(graph_json_str))
-    try:
-        fcreate = get_global_func("tvm.graph_runtime_debug.create")
-    except ValueError:
-        raise ValueError(
-            "Please set '(USE_GRAPH_RUNTIME_DEBUG ON)' in "
-            "config.cmake and rebuild TVM to enable debug mode"
-        )
-
-    ctx, num_rpc_ctx, device_type_id = graph_runtime.get_device_ctx(libmod, ctx)
-    if num_rpc_ctx == len(ctx):
-        libmod = rpc_base._ModuleHandle(libmod)
-        try:
-            fcreate = ctx[0]._rpc_sess.get_function(
-                "tvm.graph_runtime_debug.remote_create"
-            )
-        except ValueError:
-            raise ValueError(
-                "Please set '(USE_GRAPH_RUNTIME_DEBUG ON)' in "
-                "config.cmake and rebuild TVM to enable debug mode"
-            )
-    func_obj = fcreate(graph_json_str, libmod, *device_type_id)
-    return GraphModuleDebug(func_obj, ctx, graph_json_str, dump_root)
-
-
-class GraphModuleDebug(graph_runtime.GraphModule):
-    """Graph debug runtime module.
-
-    This is a debug wrapper over the TVM runtime.
-    Runtime interfaces are wrapped with debug functionalities.
-    Manage the debug framework to format the debug data and
-    trigger the user interfaces.
-
-    Parameters
-    ----------
-    module : Module
-        The interal tvm module that holds the actual graph functions.
-
-    ctx : TVMContext
-        The context this module is under.
-
-    graph_json_str : str or graph class
-        Content of graph json file in string format
-
-    dump_root : str
-        To select which folder the outputs should be kept.
-        None will make a temp folder in /tmp/tvmdbg<rand_string> and does the dumping
-    """
-
-    def __init__(self, module, ctx, graph_json_str, dump_root):
-        self._dump_root = dump_root
-        self._dump_path = None
-        self._get_output_by_layer = module["get_output_by_layer"]
-        self._run_individual = module["run_individual"]
-        graph_runtime.GraphModule.__init__(self, module)
-        self._create_debug_env(graph_json_str, ctx)
-
-    def _format_context(self, ctx):
-        return str(ctx[0]).upper().replace("(", ":").replace(")", "")
-
-    def _ensure_dir(self, directory):
-        """Create a directory if not exists
-
-        Parameters
-        ----------
-
-        directory : str
-            File path to create
-        """
-        if not os.path.exists(directory):
-            os.makedirs(directory, 0o700)
-
-    def _get_dump_path(self, ctx):
-        """Make the graph and tensor dump folder and return the path.
-
-        Parameters
-        ----------
-        ctx : TVMContext
-            The context this module is under.
-
-        Returns
-        -------
-        path : str
-            Directory path where the graph and node outputs will be stored.
-        """
-        # save to file
-        folder_name = _DUMP_PATH_PREFIX + "ctx_"
-        folder_name = folder_name + ctx.replace(":", "_")
-        path = os.path.join(self._dump_root, folder_name)
-        self._ensure_dir(path)
-        return path
-
-    def _remove_dump_root(self):
-        if os.path.isdir(self._dump_root):
-            shutil.rmtree(self._dump_root)
-
-    def _create_debug_env(self, graph_json, ctx):
-        """Create UI wrapper framework to handle multiple UI frontends for tvmdbg
-
-        Parameters
-        ----------
-        graph_json : json format
-            json formatted NNVM graph contain list of each node's name, shape and type.
-
-        nodes_list : list
-            List of all the nodes presented in the graph
-
-        ctx : TVMContext
-            The context this module is under.
-        """
-        # make the dump folder if not given
-        if not self._dump_root:
-            self._dump_root = tempfile.mkdtemp(prefix=_DUMP_ROOT_PREFIX)
-
-        # format the context
-        ctx = self._format_context(ctx)
-
-        # updates the dumping directories
-        self._dump_path = self._get_dump_path(ctx)
-
-        # init the debug dumping environment
-        self.debug_datum = debug_result.DebugResult(graph_json, self._dump_path)
-
-    def _run_debug(self):
-        """Execute the node specified with index will be executed.
-        Each debug output will be copied to the buffer
-        Time consumed for each execution will be set as debug output.
-
-        """
-        self.debug_datum._time_list = [
-            [float(t) * 1e-6] for t in self.run_individual(10, 1, 1)
-        ]
-        for i, node in enumerate(self.debug_datum.get_graph_nodes()):
-            num_outputs = self.debug_datum.get_graph_node_output_num(node)
-            for j in range(num_outputs):
-                out_tensor = self._get_output_by_layer(i, j)
-                out_tensor = array(out_tensor)
-                self.debug_datum._output_tensor_list.append(out_tensor)
-
-    def debug_get_output(self, node, out):
-        """Run graph up to node and get the output to out
-
-        Parameters
-        ----------
-        node : int / str
-            The node index or name
-
-        out : NDArray
-            The output array container
-        """
-        ret = None
-        if isinstance(node, str):
-            output_tensors = self.debug_datum.get_output_tensors()
-            try:
-                ret = output_tensors[node]
-            except:
-                node_list = output_tensors.keys()
-                raise RuntimeError(
-                    "Node "
-                    + node
-                    + " not found, available nodes are: "
-                    + str(node_list)
-                    + "."
-                )
-        elif isinstance(node, int):
-            output_tensors = self.debug_datum._output_tensor_list
-            ret = output_tensors[node]
-        else:
-            raise RuntimeError("Require node index or name only.")
-        return ret
-
-    def run(self, **input_dict):
-        """Run forward execution of the graph with debug
-
-        Parameters
-        ----------
-        input_dict : dict of str to NDArray
-            List of input values to be feed to
-        """
-        if input_dict:
-            self.set_input(**input_dict)
-
-        # Step 1. Execute the graph
-        self._run_debug()
-        # Step 2. Dump the output tensors to the dump folder
-        self.debug_datum.dump_output_tensor()
-        # Step 3. Dump the Chrome trace to the dump folder
-        self.debug_datum.dump_chrome_trace()
-        # Step 4. Display the collected information
-        self.debug_datum.display_debug_result()
-
-    def run_individual(self, number, repeat=1, min_repeat_ms=0):
-        ret = self._run_individual(number, repeat, min_repeat_ms)
-        return ret.strip(",").split(",") if ret else []
-
-
-    def exit(self):
-        """Exits the dump folder and all its contents"""
-        self._remove_dump_root()