def _register_this_run_info(self, curses_cli): curses_cli.register_command_handler( "run", self._run_handler, self._argparsers["run"].format_help(), prefix_aliases=["r"]) # TODO(Pariksheet): Python invoke_stepper implementation not support now. # curses_cli.register_command_handler( # "invoke_stepper", # self._on_run_start_step_handler, # self._argparsers["invoke_stepper"].format_help(), # prefix_aliases=["s"]) curses_cli.register_command_handler( "run_info", self._run_info_handler, self._argparsers["run_info"].format_help(), prefix_aliases=["ri"]) curses_cli.register_command_handler( "print_feed", self._print_feed_handler, self._argparsers["print_feed"].format_help(), prefix_aliases=["pf"]) if self._tensor_filters: # Register tab completion for the filter names. curses_cli.register_tab_comp_context( ["run", "r"], list(self._tensor_filters.keys())) if self._feed_dict: # Register tab completion for feed_dict keys. feed_keys = [ common.get_graph_element_name(key) for key in self._feed_dict.keys() ] curses_cli.register_tab_comp_context(["print_feed", "pf"], feed_keys)
def _print_feed_handler(self, args, screen_info=None): np_printoptions = cli_shared.numpy_printoptions_from_screen_info( screen_info) if not self._feed_dict: return cli_shared.error( "The feed_dict of the current run is None or empty.") parsed = self._argparsers["print_feed"].parse_args(args) tensor_name, tensor_slicing = ( command_parser.parse_tensor_name_with_slicing(parsed.tensor_name)) feed_key = None feed_value = None for key in self._feed_dict: key_name = common.get_graph_element_name(key) if key_name == tensor_name: feed_key = key_name feed_value = self._feed_dict[key] break if feed_key is None: return cli_shared.error( "The feed_dict of the current run does not contain the key %s" % tensor_name) return cli_shared.format_tensor( feed_value, feed_key + " (feed)", np_printoptions, print_all=parsed.print_all, tensor_slicing=tensor_slicing, highlight_options=cli_shared.parse_ranges_highlight(parsed.ranges), include_numeric_summary=parsed.numeric_summary)
def get_run_short_description(run_call_count, fetches, feed_dict, is_callable_runner=False): """Get a short description of the run() call. Args: run_call_count: (int) Run call counter. fetches: Fetches of the `GraphRuntime.run()` call. See doc of `GraphRuntime.run()` for more details. feed_dict: Feeds to the `GraphRuntime.run()` call. See doc of `GraphRuntime.run()` for more details. is_callable_runner: (bool) whether a runner returned by GraphRuntime.make_callable is being run. Returns: (str) A short description of the run() call, including information about the fetche(s) and feed(s). """ if is_callable_runner: return "runner from make_callable()" description = "run #%d: " % run_call_count if ';' not in fetches: description += "1 input (%s); " % common.get_graph_element_name( fetches) else: # Could be (nested) list, tuple, dict or namedtuple. num_fetches = len(common.get_flattened_names(fetches)) if num_fetches > 1: description += "%d outputs; " % num_fetches else: description += "%d output; " % num_fetches if not feed_dict: description += "0 inputs" else: if len(feed_dict) == 1: for key in feed_dict: description += "1 input (%s)" % ( key if isinstance(key, six.string_types) or not hasattr(key, "name") else key.name) else: description += "%d inputs" % len(feed_dict) return description
def get_run_start_intro(run_call_count, fetches, feed_dict, tensor_filters, is_callable_runner=False): """Generate formatted intro for run-start UI. Args: run_call_count: (int) Run call counter. fetches: Fetches of the `GraphRuntime.run()` call. See doc of `GraphRuntime.run()` for more details. feed_dict: Feeds to the `GraphRuntime.run()` call. See doc of `GraphRuntime.run()` for more details. tensor_filters: (dict) A dict from tensor-filter name to tensor-filter callable. is_callable_runner: (bool) whether a runner returned by GraphRuntime.make_callable is being run. Returns: (RichTextLines) Formatted intro message about the `GraphRuntime.run()` call. """ fetch_lines = common.get_flattened_names(fetches) if not feed_dict: feed_dict_lines = [debugger_cli_common.RichLine(" (Empty)")] else: feed_dict_lines = [] for feed_key in feed_dict: feed_key_name = common.get_graph_element_name(feed_key) feed_dict_line = debugger_cli_common.RichLine(" ") feed_dict_line += debugger_cli_common.RichLine( feed_key_name, debugger_cli_common.MenuItem(None, "pf '%s'" % feed_key_name)) # Surround the name string with quotes, because feed_key_name may contain # spaces in some cases, e.g., SparseTensors. feed_dict_lines.append(feed_dict_line) feed_dict_lines = debugger_cli_common.rich_text_lines_from_rich_line_list( feed_dict_lines) out = debugger_cli_common.RichTextLines(_HORIZONTAL_BAR) if is_callable_runner: out.append( " Running a runner returned by GraphRuntime.make_callable()") else: out.append(" GraphRuntime.run() call #%d:" % run_call_count) out.append("") out.append(" Output:") out.extend( debugger_cli_common.RichTextLines( [" " + line for line in fetch_lines])) out.append("") out.append(" Inputs:") out.extend(feed_dict_lines) out.append(_HORIZONTAL_BAR) out.append("") out.append(" Select one of the following commands to proceed ---->") out.extend( _recommend_command("run", "Execute the run() call with debug tensor-watching", create_link=True)) out.extend( _recommend_command( "run -n", "Execute the run() call without debug tensor-watching", create_link=True)) out.extend( _recommend_command( "run -t <T>", "Execute run() calls (T - 1) times without debugging, then " "execute run() once more with debugging and drop back to the CLI")) out.extend( _recommend_command( "run -f <filter_name>", "Keep executing run() calls until a dumped tensor passes a given, " "registered filter (conditional breakpoint mode)")) more_lines = [" Registered filter(s):"] if tensor_filters: filter_names = [] for filter_name in tensor_filters: filter_names.append(filter_name) command_menu_node = debugger_cli_common.MenuItem( "", "run -f %s" % filter_name) more_lines.append( RL(" * ") + RL(filter_name, command_menu_node)) else: more_lines.append(" (None)") out.extend( debugger_cli_common.rich_text_lines_from_rich_line_list(more_lines)) # TODO(Pariksheet): Python invoke_stepper implementation not support now. # out.extend( # _recommend_command( # "invoke_stepper", # "Use the node-stepper interface, which allows you to interactively " # "step through nodes involved in the graph run() call and " # "inspect/modify their values", create_link=True)) out.append("") # out.append_rich_line(RL("For more details, see ") + # RL("help.", debugger_cli_common.MenuItem("", "help")) + # ".") # out.append("") # Make main menu for the run-start intro. menu = debugger_cli_common.Menu() menu.append(debugger_cli_common.MenuItem("run", "run")) # TODO(Pariksheet): Python invoke_stepper implementation not support now. # menu.append(debugger_cli_common.MenuItem( # "invoke_stepper", "invoke_stepper")) menu.append(debugger_cli_common.MenuItem("exit", "exit")) out.annotations[debugger_cli_common.MAIN_MENU_KEY] = menu return out