Please guide me in the right direction. I am able to get .as_graph() to display the model correctly

Axon.Display.as_graph(model, template)

however when I try to run .as_table() I get an error (CAUTION: wall of error text follows):

Axon.Display.as_table(model, template)
|> IO.puts

** (FunctionClauseError) no function clause matching in Axon.Display.do_axon_to_rows/6    
    
    The following arguments were given to Axon.Display.do_axon_to_rows/6:
    
        # 1
        %Axon.Node{
          id: 5,
          name: #Function<194.57606554/2 in Axon.name/2>,
          mode: :both,
          parent: [4],
          parameters: [],
          args: [:layer],
          op: :softmax,
          policy: #Axon.MixedPrecision.Policy<>,
          hooks: [],
          opts: [],
          global_options: [],
          op_name: :softmax,
          meta: %{},
          stacktrace: [
            {Axon, :layer, 3, [file: ~c"lib/axon.ex", line: 346]},
            {:elixir, :eval_external_handler, 3, [file: ~c"src/elixir.erl", line: 388]},
            {:erl_eval, :do_apply, 7, [file: ~c"erl_eval.erl", line: 919]},
            {:erl_eval, :expr, 6, [file: ~c"erl_eval.erl", line: 663]},
            {:elixir, :eval_forms, 4, [file: ~c"src/elixir.erl", line: 366]},
            {Module.ParallelChecker, :verify, 1, [file: ~c"lib/module/parallel_checker.ex", line: 120]}
          ]
        }
    
        # 2
        %{
          1 => %Axon.Node{
            id: 1,
            name: #Function<195.57606554/2 in Axon.name/2>,
            mode: :both,
            parent: [],
            parameters: [],
            args: [],
            op: :input,
            policy: #Axon.MixedPrecision.Policy<>,
            hooks: [],
            opts: [shape: {nil, 748}, optional: false],
            global_options: [],
            op_name: :input,
            meta: nil,
            stacktrace: [
              {Axon, :layer, 3, [file: ~c"lib/axon.ex", line: 346]},
              {:elixir, :eval_external_handler, 3, [file: ~c"src/elixir.erl", line: 388]},
              {:erl_eval, :do_apply, 7, [file: ~c"erl_eval.erl", line: 919]},
              {:erl_eval, :expr_list, 7, [file: ~c"erl_eval.erl", line: 1207]},
              {:erl_eval, :expr, 6, [file: ~c"erl_eval.erl", line: 625]},
              {:erl_eval, :expr_list, 7, [file: ~c"erl_eval.erl", line: 1207]}
            ]
          },
          2 => %Axon.Node{
            id: 2,
            name: #Function<194.57606554/2 in Axon.name/2>,
            mode: :both,
            parent: [1],
            parameters: [
              %Axon.Parameter{
                name: "kernel",
                template: #Function<485.57606554/1 in Axon.shape_fun/2>,
                shape: nil,
                initializer: #Function<3.47872556/3 in Axon.Initializers.glorot_uniform/1>,
                children: nil,
                type: {:f, 32},
                frozen: false,
                kind: :parameter
              },
              %Axon.Parameter{
                name: "bias",
                template: #Function<485.57606554/1 in Axon.shape_fun/2>,
                shape: nil,
                initializer: #Function<23.47872556/2 in Axon.Initializers.zeros/0>,
                children: nil,
                type: {:f, 32},
                frozen: false,
                kind: :parameter
              }
            ],
            args: [:layer, :parameter, :parameter],
            op: :dense,
            policy: #Axon.MixedPrecision.Policy<>,
            hooks: [],
            opts: [],
            global_options: [],
            op_name: :dense,
            meta: %{use_bias: true, units: 128},
            stacktrace: [
              {Axon, :layer, 3, [file: ~c"lib/axon.ex", line: 346]},
              {Axon, :dense, 3, [file: ~c"lib/axon.ex", line: 877]},
              {:elixir, :eval_external_handler, 3, [file: ~c"src/elixir.erl", line: 388]},
              {:erl_eval, :do_apply, 7, [file: ~c"erl_eval.erl", line: 919]},
              {:erl_eval, :expr_list, 7, [file: ~c"erl_eval.erl", line: 1207]},
              {:erl_eval, :expr, 6, [file: ~c"erl_eval.erl", line: 625]}
            ]
          },
          3 => %Axon.Node{
            id: 3,
            name: #Function<194.57606554/2 in Axon.name/2>,
            mode: :both,
            parent: [2],
            parameters: [],
            args: [:layer],
            op: :relu,
            policy: #Axon.MixedPrecision.Policy<>,
            hooks: [],
            opts: [],
            global_options: [],
            op_name: :relu,
            meta: %{},
            stacktrace: [
              {Axon, :layer, 3, [file: ~c"lib/axon.ex", line: 346]},
              {:elixir, :eval_external_handler, 3, [file: ~c"src/elixir.erl", line: 388]},
              {:erl_eval, :do_apply, 7, [file: ~c"erl_eval.erl", line: 919]},
              {:erl_eval, :expr_list, 7, [file: ~c"erl_eval.erl", line: 1207]},
              {:erl_eval, :expr, 6, [file: ~c"erl_eval.erl", line: 625]},
              {:erl_eval, :expr, 6, [file: ~c"erl_eval.erl", line: 663]}
            ]
          },
          4 => %Axon.Node{
            id: 4,
            name: #Function<194.57606554/2 in Axon.name/2>,
            mode: :both,
            parent: [3],
            parameters: [
              %Axon.Parameter{
                name: "kernel",
                template: #Function<485.57606554/1 in Axon.shape_fun/2>,
                shape: nil,
                initializer: #Function<3.47872556/3 in Axon.Initializers.glorot_uniform/1>,
                children: nil,
                type: {:f, 32},
                frozen: false,
                kind: :parameter
              },
              %Axon.Parameter{
                name: "bias",
                template: #Function<485.57606554/1 in Axon.shape_fun/2>,
                shape: nil,
                initializer: #Function<23.47872556/2 in Axon.Initializers.zeros/0>,
                children: nil,
                type: {:f, 32},
                frozen: false,
                kind: :parameter
              }
            ],
            args: [:layer, :parameter, :parameter],
            op: :dense,
            policy: #Axon.MixedPrecision.Policy<>,
            hooks: [],
            opts: [],
            global_options: [],
            op_name: :dense,
            meta: %{use_bias: true, units: 10},
            stacktrace: [
              {Axon, :layer, 3, [file: ~c"lib/axon.ex", line: 346]},
              {Axon, :dense, 3, [file: ~c"lib/axon.ex", line: 877]},
              {:elixir, :eval_external_handler, 3, [file: ~c"src/elixir.erl", line: 388]},
              {:erl_eval, :do_apply, 7, [file: ~c"erl_eval.erl", line: 919]},
              {:erl_eval, :expr, 6, [file: ~c"erl_eval.erl", line: 663]},
              {:elixir, :eval_forms, 4, [file: ~c"src/elixir.erl", line: 366]}
            ]
          },
          5 => %Axon.Node{
            id: 5,
            name: #Function<194.57606554/2 in Axon.name/2>,
            mode: :both,
            parent: [4],
            parameters: [],
            args: [:layer],
            op: :softmax,
            policy: #Axon.MixedPrecision.Policy<>,
            hooks: [],
            opts: [],
            global_options: [],
            op_name: :softmax,
            meta: %{},
            stacktrace: [
              {Axon, :layer, 3, [file: ~c"lib/axon.ex", line: 346]},
              {:elixir, :eval_external_handler, 3, [file: ~c"src/elixir.erl", line: 388]},
              {:erl_eval, :do_apply, 7, [file: ~c"erl_eval.erl", line: 919]},
              {:erl_eval, :expr, 6, [file: ~c"erl_eval.erl", line: 663]},
              {:elixir, :eval_forms, 4, [file: ~c"src/elixir.erl", line: 366]},
              {Module.ParallelChecker, :verify, 1, [file: ~c"lib/module/parallel_checker.ex", line: 120]}
            ]
          }
        }
    
        # 3
        #Nx.Tensor<
          f32[1][784]
          Nx.TemplateBackend
        >
    
        # 4
        %{}
    
        # 5
        %{}
    
        # 6
        %{num_params: 0, total_param_byte_size: 0}
    
    Attempted function clauses (showing 2 out of 2):
    
        defp do_axon_to_rows(%Axon.Node{id: id, op: structure, op_name: :container, parent: [parents], name: name_fn}, nodes, templates, cache, op_counts, model_info)
        defp do_axon_to_rows(%Axon.Node{
      id: id,
      parent: parents,
      parameters: params,
      name: name_fn,
      opts: opts,
      policy: %{params: {_, bitsize}},
      op_name: op_name
    }, nodes, templates, cache, op_counts, model_info)
    
    (axon 0.7.0) lib/axon/display.ex:93: Axon.Display.do_axon_to_rows/6
    (axon 0.7.0) lib/axon/display.ex:85: Axon.Display.axon_to_rows/6
    (axon 0.7.0) lib/axon/display.ex:39: Axon.Display.as_table/2
    #cell:r744jk7wwgcawf6v:2: (file)

Perhaps not hyper important as the graph contains the same info but it is nice how the table has the labels.