node_name=None,

enable_list_tensors=True,

enable_node_info=True,

enable_print_tensor=True,

enable_list_inputs=True,

enable_list_outputs=True):

"""Generate main menu for the screen output from a command.

menu = debugger_cli_common.Menu()

menu.append(

debugger_cli_common.MenuItem(

"list_tensors", "list_tensors", enabled=enable_list_tensors))

if node_name:

menu.append(

debugger_cli_common.MenuItem(

"node_info",

"node_info -a -d -t %s" % node_name,

enabled=enable_node_info))

menu.append(

debugger_cli_common.MenuItem(

"print_tensor",

"print_tensor %s" % node_name,

enabled=enable_print_tensor))

menu.append(

debugger_cli_common.MenuItem(

"list_inputs",

"list_inputs -c -r %s" % node_name,

enabled=enable_list_inputs))

menu.append(

debugger_cli_common.MenuItem(

"list_outputs",

"list_outputs -c -r %s" % node_name,

enabled=enable_list_outputs))

else:

menu.append(

debugger_cli_common.MenuItem(

"node_info", None, enabled=False))

menu.append(

debugger_cli_common.MenuItem("print_tensor", None, enabled=False))

menu.append(

debugger_cli_common.MenuItem("list_inputs", None, enabled=False))

menu.append(

debugger_cli_common.MenuItem("list_outputs", None, enabled=False))

menu.append(

debugger_cli_common.MenuItem("run_info", "run_info"))

menu.append(

debugger_cli_common.MenuItem("help", "help"))

"""Analyzer for debug data from dump directories."""

_TIMESTAMP_COLUMN_HEAD = "t (ms)"

_DUMP_SIZE_COLUMN_HEAD = "Size (B)"

_OP_TYPE_COLUMN_HEAD = "Op type"

_TENSOR_NAME_COLUMN_HEAD = "Tensor name"

# Op types to be omitted when generating descriptions of graph structure.

_GRAPH_STRUCT_OP_TYPE_BLACKLIST = (

"_Send", "_Recv", "_HostSend", "_HostRecv", "_Retval")

def __init__(self, debug_dump):

"""DebugAnalyzer constructor.

self._debug_dump = debug_dump

self._evaluator = evaluator.ExpressionEvaluator(self._debug_dump)

# Initialize tensor filters state.

self._tensor_filters = {}

# Argument parsers for command handlers.

self._arg_parsers = {}

# Parser for list_tensors.

ap = argparse.ArgumentParser(

description="List dumped intermediate tensors.",

usage=argparse.SUPPRESS)

ap.add_argument(

"-f",

"--tensor_filter",

dest="tensor_filter",

type=str,

default="",

help="List only Tensors passing the filter of the specified name")

ap.add_argument(

"-n",

"--node_name_filter",

dest="node_name_filter",

type=str,

default="",

help="filter node name by regex.")

ap.add_argument(

"-t",

"--op_type_filter",

dest="op_type_filter",

type=str,

default="",

help="filter op type by regex.")

ap.add_argument(

"-s",

"--sort_by",

dest="sort_by",

type=str,

default=SORT_TENSORS_BY_TIMESTAMP,

help=("the field to sort the data by: (%s | %s | %s | %s)" %

(SORT_TENSORS_BY_TIMESTAMP, SORT_TENSORS_BY_DUMP_SIZE,

SORT_TENSORS_BY_OP_TYPE, SORT_TENSORS_BY_TENSOR_NAME)))

ap.add_argument(

"-r",

"--reverse",

dest="reverse",

action="store_true",

help="sort the data in reverse (descending) order")

self._arg_parsers["list_tensors"] = ap

# Parser for node_info.

ap = argparse.ArgumentParser(

description="Show information about a node.", usage=argparse.SUPPRESS)

ap.add_argument(

"node_name",

type=str,

help="Name of the node or an associated tensor, e.g., "

"hidden1/Wx_plus_b/MatMul, hidden1/Wx_plus_b/MatMul:0")

ap.add_argument(

"-a",

"--attributes",

dest="attributes",

action="store_true",

help="Also list attributes of the node.")

ap.add_argument(

"-d",

"--dumps",

dest="dumps",

action="store_true",

help="Also list dumps available from the node.")

ap.add_argument(

"-t",

"--traceback",

dest="traceback",

action="store_true",

help="Also include the traceback of the node's creation "

"(if available in Python).")

self._arg_parsers["node_info"] = ap

# Parser for list_inputs.

ap = argparse.ArgumentParser(

description="Show inputs to a node.", usage=argparse.SUPPRESS)

ap.add_argument(

"node_name",

type=str,

help="Name of the node or an output tensor from the node, e.g., "

"hidden1/Wx_plus_b/MatMul, hidden1/Wx_plus_b/MatMul:0")

ap.add_argument(

"-c", "--control", action="store_true", help="Include control inputs.")

ap.add_argument(

"-d",

"--depth",

dest="depth",

type=int,

default=20,

help="Maximum depth of recursion used when showing the input tree.")

ap.add_argument(

"-r",

"--recursive",

dest="recursive",

action="store_true",

help="Show inputs to the node recursively, i.e., the input tree.")

ap.add_argument(

"-t",

"--op_type",

action="store_true",

help="Show op types of input nodes.")

self._arg_parsers["list_inputs"] = ap

# Parser for list_outputs.

ap = argparse.ArgumentParser(

description="Show the nodes that receive the outputs of given node.",

usage=argparse.SUPPRESS)

ap.add_argument(

"node_name",

type=str,

help="Name of the node or an output tensor from the node, e.g., "

"hidden1/Wx_plus_b/MatMul, hidden1/Wx_plus_b/MatMul:0")

ap.add_argument(

"-c", "--control", action="store_true", help="Include control inputs.")

ap.add_argument(

"-d",

"--depth",

dest="depth",

type=int,

default=20,

help="Maximum depth of recursion used when showing the output tree.")

ap.add_argument(

"-r",

"--recursive",

dest="recursive",

action="store_true",

help="Show recipients of the node recursively, i.e., the output "

"tree.")

ap.add_argument(

"-t",

"--op_type",

action="store_true",

help="Show op types of recipient nodes.")

self._arg_parsers["list_outputs"] = ap

# Parser for print_tensor.

self._arg_parsers["print_tensor"] = (

command_parser.get_print_tensor_argparser(

"Print the value of a dumped tensor."))

# Parser for print_source.

ap = argparse.ArgumentParser(

description="Print a Python source file with overlaid debug "

"information, including the nodes (ops) or Tensors created at the "

"source lines.",

usage=argparse.SUPPRESS)

ap.add_argument(

"source_file_path",

type=str,

help="Path to the source file.")

ap.add_argument(

"-t",

"--tensors",

dest="tensors",

action="store_true",

help="Label lines with dumped Tensors, instead of ops.")

ap.add_argument(

"-m",

"--max_elements_per_line",

type=int,

default=10,

help="Maximum number of elements (ops or Tensors) to show per source "

"line.")

ap.add_argument(

"-b",

"--line_begin",

type=int,

default=1,

help="Print source beginning at line number (1-based.)")

self._arg_parsers["print_source"] = ap

# Parser for list_source.

ap = argparse.ArgumentParser(

description="List source files responsible for constructing nodes and "

"tensors present in the run().",

usage=argparse.SUPPRESS)

ap.add_argument(

"-p",

"--path_filter",

type=str,

default="",

help="Regular expression filter for file path.")

ap.add_argument(

"-n",

"--node_name_filter",

type=str,

default="",

help="Regular expression filter for node name.")

self._arg_parsers["list_source"] = ap

# Parser for eval.

ap = argparse.ArgumentParser(

description="""Evaluate an arbitrary expression. Can use tensor values

""",

usage=argparse.SUPPRESS)

ap.add_argument(

"expression",

type=str,

help="""Expression to be evaluated.

/job:worker/replica:0/task:0/gpu:0:RNN/tanh:0[0].""")

ap.add_argument(

"-a",

"--all",

dest="print_all",

action="store_true",

help="Print the tensor in its entirety, i.e., do not use ellipses "

"(may be slow for large results).")

self._arg_parsers["eval"] = ap

# TODO(cais): Implement list_nodes.

def add_tensor_filter(self, filter_name, filter_callable):

"""Add a tensor filter.

if not isinstance(filter_name, str):

raise TypeError("Input argument filter_name is expected to be str, "

"but is not.")

# Check that filter_name is not an empty str.

if not filter_name:

raise ValueError("Input argument filter_name cannot be empty.")

# Check that filter_callable is callable.

if not callable(filter_callable):

raise TypeError(

"Input argument filter_callable is expected to be callable, "

"but is not.")

self._tensor_filters[filter_name] = filter_callable

def get_tensor_filter(self, filter_name):

"""Retrieve filter function by name.

if filter_name not in self._tensor_filters:

raise ValueError("There is no tensor filter named \"%s\"" % filter_name)

return self._tensor_filters[filter_name]

def get_help(self, handler_name):

return self._arg_parsers[handler_name].format_help()

def list_tensors(self, args, screen_info=None):

"""Command handler for list_tensors.

# TODO(cais): Add annotations of substrings for dumped tensor names, to

# facilitate on-screen highlighting/selection of node names.

_ = screen_info

parsed = self._arg_parsers["list_tensors"].parse_args(args)

output = []

filter_strs = []

if parsed.op_type_filter:

op_type_regex = re.compile(parsed.op_type_filter)

filter_strs.append("Op type regex filter: \"%s\"" % parsed.op_type_filter)

else:

op_type_regex = None

if parsed.node_name_filter:

node_name_regex = re.compile(parsed.node_name_filter)

filter_strs.append("Node name regex filter: \"%s\"" %

parsed.node_name_filter)

else:

node_name_regex = None

output = debugger_cli_common.RichTextLines(filter_strs)

output.append("")

if parsed.tensor_filter:

try:

filter_callable = self.get_tensor_filter(parsed.tensor_filter)

except ValueError:

output = cli_shared.error("There is no tensor filter named \"%s\"." %

parsed.tensor_filter)

_add_main_menu(output, node_name=None, enable_list_tensors=False)

return output

data_to_show = self._debug_dump.find(filter_callable)

else:

data_to_show = self._debug_dump.dumped_tensor_data

# TODO(cais): Implement filter by lambda on tensor value.

max_timestamp_width, max_dump_size_width, max_op_type_width = (

self._measure_tensor_list_column_widths(data_to_show))

# Sort the data.

data_to_show = self._sort_dump_data_by(

data_to_show, parsed.sort_by, parsed.reverse)

output.extend(

self._tensor_list_column_heads(parsed, max_timestamp_width,

max_dump_size_width, max_op_type_width))

dump_count = 0

for dump in data_to_show:

if node_name_regex and not node_name_regex.match(dump.node_name):

continue

if op_type_regex:

op_type = self._debug_dump.node_op_type(dump.node_name)

if not op_type_regex.match(op_type):

continue

rel_time = (dump.timestamp - self._debug_dump.t0) / 1000.0

dump_size_str = cli_shared.bytes_to_readable_str(dump.dump_size_bytes)

dumped_tensor_name = "%s:%d" % (dump.node_name, dump.output_slot)

op_type = self._debug_dump.node_op_type(dump.node_name)

line = "[%.3f]" % rel_time

line += " " * (max_timestamp_width - len(line))

line += dump_size_str

line += " " * (max_timestamp_width + max_dump_size_width - len(line))

line += op_type

line += " " * (max_timestamp_width + max_dump_size_width +

max_op_type_width - len(line))

line += dumped_tensor_name

output.append(

line,

font_attr_segs=[(

len(line) - len(dumped_tensor_name), len(line),

debugger_cli_common.MenuItem("", "pt %s" % dumped_tensor_name))])

dump_count += 1

if parsed.tensor_filter:

output.prepend([

"%d dumped tensor(s) passing filter \"%s\":" %

(dump_count, parsed.tensor_filter)

])

else:

output.prepend(["%d dumped tensor(s):" % dump_count])

_add_main_menu(output, node_name=None, enable_list_tensors=False)

return output

def _measure_tensor_list_column_widths(self, data):

"""Determine the maximum widths of the timestamp and op-type column.

max_timestamp_width = 0

if data:

max_rel_time_ms = (data[-1].timestamp - self._debug_dump.t0) / 1000.0

max_timestamp_width = len("[%.3f] " % max_rel_time_ms) + 1

max_timestamp_width = max(max_timestamp_width,

len(self._TIMESTAMP_COLUMN_HEAD) + 1)

max_dump_size_width = 0

for dump in data:

dump_size_str = cli_shared.bytes_to_readable_str(dump.dump_size_bytes)

if len(dump_size_str) + 1 > max_dump_size_width:

max_dump_size_width = len(dump_size_str) + 1

max_dump_size_width = max(max_dump_size_width,

len(self._DUMP_SIZE_COLUMN_HEAD) + 1)

max_op_type_width = 0

for dump in data:

op_type = self._debug_dump.node_op_type(dump.node_name)

if len(op_type) + 1 > max_op_type_width:

max_op_type_width = len(op_type) + 1

max_op_type_width = max(max_op_type_width,

len(self._OP_TYPE_COLUMN_HEAD) + 1)

return max_timestamp_width, max_dump_size_width, max_op_type_width

def _sort_dump_data_by(self, data, sort_by, reverse):

"""Sort a list of DebugTensorDatum in specified order.

if sort_by == SORT_TENSORS_BY_TIMESTAMP:

return sorted(

data,

reverse=reverse,

key=lambda x: x.timestamp)

elif sort_by == SORT_TENSORS_BY_DUMP_SIZE:

return sorted(data, reverse=reverse, key=lambda x: x.dump_size_bytes)

elif sort_by == SORT_TENSORS_BY_OP_TYPE:

return sorted(

data,

reverse=reverse,

key=lambda x: self._debug_dump.node_op_type(x.node_name))

elif sort_by == SORT_TENSORS_BY_TENSOR_NAME:

return sorted(

data,

reverse=reverse,

key=lambda x: "%s:%d" % (x.node_name, x.output_slot))

else:

raise ValueError("Unsupported key to sort tensors by: %s" % sort_by)

def _tensor_list_column_heads(self, parsed, max_timestamp_width,

max_dump_size_width, max_op_type_width):

"""Generate a line containing the column heads of the tensor list.

base_command = "list_tensors"

if parsed.tensor_filter:

base_command += " -f %s" % parsed.tensor_filter

if parsed.op_type_filter:

base_command += " -t %s" % parsed.op_type_filter

if parsed.node_name_filter:

base_command += " -n %s" % parsed.node_name_filter

attr_segs = {0: []}

row = self._TIMESTAMP_COLUMN_HEAD

command = "%s -s %s" % (base_command, SORT_TENSORS_BY_TIMESTAMP)

if parsed.sort_by == SORT_TENSORS_BY_TIMESTAMP and not parsed.reverse:

command += " -r"

attr_segs[0].append(

(0, len(row), [debugger_cli_common.MenuItem(None, command), "bold"]))

row += " " * (max_timestamp_width - len(row))

prev_len = len(row)

row += self._DUMP_SIZE_COLUMN_HEAD

command = "%s -s %s" % (base_command, SORT_TENSORS_BY_DUMP_SIZE)

if parsed.sort_by == SORT_TENSORS_BY_DUMP_SIZE and not parsed.reverse:

command += " -r"

attr_segs[0].append((prev_len, len(row),

[debugger_cli_common.MenuItem(None, command), "bold"]))

row += " " * (max_dump_size_width + max_timestamp_width - len(row))

prev_len = len(row)

row += self._OP_TYPE_COLUMN_HEAD

command = "%s -s %s" % (base_command, SORT_TENSORS_BY_OP_TYPE)

if parsed.sort_by == SORT_TENSORS_BY_OP_TYPE and not parsed.reverse:

command += " -r"

attr_segs[0].append((prev_len, len(row),

[debugger_cli_common.MenuItem(None, command), "bold"]))

row += " " * (

max_op_type_width + max_dump_size_width + max_timestamp_width - len(row)

)

prev_len = len(row)

row += self._TENSOR_NAME_COLUMN_HEAD

command = "%s -s %s" % (base_command, SORT_TENSORS_BY_TENSOR_NAME)

if parsed.sort_by == SORT_TENSORS_BY_TENSOR_NAME and not parsed.reverse:

command += " -r"

attr_segs[0].append((prev_len, len(row),

[debugger_cli_common.MenuItem("", command), "bold"]))

row += " " * (

max_op_type_width + max_dump_size_width + max_timestamp_width - len(row)

)

return debugger_cli_common.RichTextLines([row], font_attr_segs=attr_segs)

def node_info(self, args, screen_info=None):

"""Command handler for node_info.

# TODO(cais): Add annotation of substrings for node names, to facilitate

# on-screen highlighting/selection of node names.

_ = screen_info

parsed = self._arg_parsers["node_info"].parse_args(args)

# Get a node name, regardless of whether the input is a node name (without

# output slot attached) or a tensor name (with output slot attached).

node_name, unused_slot = debug_graphs.parse_node_or_tensor_name(

parsed.node_name)

if not self._debug_dump.node_exists(node_name):

output = cli_shared.error(

"There is no node named \"%s\" in the partition graphs" % node_name)

_add_main_menu(

output,

node_name=None,

enable_list_tensors=True,

enable_node_info=False,

enable_list_inputs=False,

enable_list_outputs=False)

return output

# TODO(cais): Provide UI glossary feature to explain to users what the

# term "partition graph" means and how it is related to TF graph objects

# in Python. The information can be along the line of:

# "A tensorflow graph defined in Python is stripped of unused ops

# according to the feeds and fetches and divided into a number of

# partition graphs that may be distributed among multiple devices and

# hosts. The partition graphs are what's actually executed by the C++

# runtime during a run() call."

lines = ["Node %s" % node_name]

font_attr_segs = {

0: [(len(lines[-1]) - len(node_name), len(lines[-1]), "bold")]

}

lines.append("")

lines.append(" Op: %s" % self._debug_dump.node_op_type(node_name))

lines.append(" Device: %s" % self._debug_dump.node_device(node_name))

output = debugger_cli_common.RichTextLines(

lines, font_attr_segs=font_attr_segs)

# List node inputs (non-control and control).

inputs = self._exclude_blacklisted_ops(

self._debug_dump.node_inputs(node_name))

ctrl_inputs = self._exclude_blacklisted_ops(

self._debug_dump.node_inputs(node_name, is_control=True))

output.extend(self._format_neighbors("input", inputs, ctrl_inputs))

# List node output recipients (non-control and control).

recs = self._exclude_blacklisted_ops(

self._debug_dump.node_recipients(node_name))

ctrl_recs = self._exclude_blacklisted_ops(

self._debug_dump.node_recipients(node_name, is_control=True))

output.extend(self._format_neighbors("recipient", recs, ctrl_recs))

# Optional: List attributes of the node.

if parsed.attributes:

output.extend(self._list_node_attributes(node_name))

# Optional: List dumps available from the node.

if parsed.dumps:

output.extend(self._list_node_dumps(node_name))

if parsed.traceback:

output.extend(self._render_node_traceback(node_name))

_add_main_menu(output, node_name=node_name, enable_node_info=False)

return output

def _exclude_blacklisted_ops(self, node_names):

"""Exclude all nodes whose op types are in _GRAPH_STRUCT_OP_TYPE_BLACKLIST.

return [node_name for node_name in node_names

if self._debug_dump.node_op_type(

debug_graphs.get_node_name(node_name)) not in

self._GRAPH_STRUCT_OP_TYPE_BLACKLIST]

def _render_node_traceback(self, node_name):

"""Render traceback of a node's creation in Python, if available.

lines = [RL(""), RL(""), RL("Traceback of node construction:", "bold")]

try:

node_stack = self._debug_dump.node_traceback(node_name)

for depth, (file_path, line, function_name, text) in enumerate(

node_stack):

lines.append("%d: %s" % (depth, file_path))

attribute = debugger_cli_common.MenuItem(

"", "ps %s -b %d" % (file_path, line)) if text else None

line_number_line = RL(" ")

line_number_line += RL("Line: %d" % line, attribute)

lines.append(line_number_line)

lines.append(" Function: %s" % function_name)

lines.append(" Text: " + (("\"%s\"" % text) if text else "None"))

lines.append("")

except KeyError:

lines.append("(Node unavailable in the loaded Python graph)")

except LookupError:

lines.append("(Unavailable because no Python graph has been loaded)")

return debugger_cli_common.rich_text_lines_from_rich_line_list(lines)

def list_inputs(self, args, screen_info=None):

"""Command handler for inputs.

# Screen info not currently used by this handler. Include this line to

# mute pylint.

_ = screen_info

# TODO(cais): Use screen info to format the output lines more prettily,

# e.g., hanging indent of long node names.

parsed = self._arg_parsers["list_inputs"].parse_args(args)

output = self._list_inputs_or_outputs(

parsed.recursive,

parsed.node_name,

parsed.depth,

parsed.control,

parsed.op_type,

do_outputs=False)

node_name = debug_graphs.get_node_name(parsed.node_name)

_add_main_menu(output, node_name=node_name, enable_list_inputs=False)

return output

def print_tensor(self, args, screen_info=None):

"""Command handler for print_tensor.

parsed = self._arg_parsers["print_tensor"].parse_args(args)

np_printoptions = cli_shared.numpy_printoptions_from_screen_info(

screen_info)

# Determine if any range-highlighting is required.

highlight_options = cli_shared.parse_ranges_highlight(parsed.ranges)

tensor_name, tensor_slicing = (

command_parser.parse_tensor_name_with_slicing(parsed.tensor_name))

node_name, output_slot = debug_graphs.parse_node_or_tensor_name(tensor_name)

if (self._debug_dump.loaded_partition_graphs() and

not self._debug_dump.node_exists(node_name)):

output = cli_shared.error(

"Node \"%s\" does not exist in partition graphs" % node_name)

_add_main_menu(

output,

node_name=None,

enable_list_tensors=True,

enable_print_tensor=False)

return output

watch_keys = self._debug_dump.debug_watch_keys(node_name)

if output_slot is None:

output_slots = set()

for watch_key in watch_keys:

output_slots.add(int(watch_key.split(":")[1]))

if len(output_slots) == 1:

# There is only one dumped tensor from this node, so there is no

# ambiguity. Proceed to show the only dumped tensor.

output_slot = list(output_slots)[0]

else:

# There are more than one dumped tensors from this node. Indicate as

# such.

# TODO(cais): Provide an output screen with command links for

# convenience.

lines = [

"Node \"%s\" generated debug dumps from %s output slots:" %

(node_name, len(output_slots)),

"Please specify the output slot: %s:x." % node_name

]

output = debugger_cli_common.RichTextLines(lines)

_add_main_menu(

output,

node_name=node_name,

enable_list_tensors=True,

enable_print_tensor=False)

return output

# Find debug dump data that match the tensor name (node name + output

# slot).

matching_data = []

for watch_key in watch_keys:

debug_tensor_data = self._debug_dump.watch_key_to_data(watch_key)

for datum in debug_tensor_data:

if datum.output_slot == output_slot:

matching_data.append(datum)

if not matching_data:

# No dump for this tensor.

output = cli_shared.error("Tensor \"%s\" did not generate any dumps." %

parsed.tensor_name)

elif len(matching_data) == 1:

# There is only one dump for this tensor.

if parsed.number <= 0:

output = cli_shared.format_tensor(

matching_data[0].get_tensor(),

matching_data[0].watch_key,

np_printoptions,

print_all=parsed.print_all,

tensor_slicing=tensor_slicing,

highlight_options=highlight_options,

include_numeric_summary=parsed.numeric_summary)

else:

output = cli_shared.error(

"Invalid number (%d) for tensor %s, which generated one dump." %

(parsed.number, parsed.tensor_name))

_add_main_menu(output, node_name=node_name, enable_print_tensor=False)

else:

# There are more than one dumps for this tensor.

if parsed.number < 0:

lines = [

"Tensor \"%s\" generated %d dumps:" % (parsed.tensor_name,

len(matching_data))

]

font_attr_segs = {}

for i, datum in enumerate(matching_data):

rel_time = (datum.timestamp - self._debug_dump.t0) / 1000.0

lines.append("#%d [%.3f ms] %s" % (i, rel_time, datum.watch_key))

command = "print_tensor %s -n %d" % (parsed.tensor_name, i)

font_attr_segs[len(lines) - 1] = [(

len(lines[-1]) - len(datum.watch_key), len(lines[-1]),

debugger_cli_common.MenuItem(None, command))]

lines.append("")

lines.append(

"You can use the -n (--number) flag to specify which dump to "

"print.")

lines.append("For example:")

lines.append(" print_tensor %s -n 0" % parsed.tensor_name)

output = debugger_cli_common.RichTextLines(

lines, font_attr_segs=font_attr_segs)

elif parsed.number >= len(matching_data):

output = cli_shared.error(

"Specified number (%d) exceeds the number of available dumps "

"(%d) for tensor %s" %

(parsed.number, len(matching_data), parsed.tensor_name))

else:

output = cli_shared.format_tensor(

matching_data[parsed.number].get_tensor(),

matching_data[parsed.number].watch_key + " (dump #%d)" %