Fix Inspector compare_results crash on non-tensor outputs (pytorch#23276)

### Summary

The Inspector's compare_results crashes as soon as one of the outputs
isn't a tensor. calculate_mse / calculate_snr /
calculate_cosine_similarity return None for non-tensor outputs, and then
the print loop does f"{value:>8.5f}" on it and dies with "TypeError:
unsupported format string passed to NoneType.__format__". plot=True
breaks the same way (max() and plt.bar on None).

The CLI hits a related problem: `inspector_cli --compare_results` calls
compare_results even when there's no reference output (no ETRecord with
reference outputs), so it fails there too.

Changes:
- print "N/A" for None values instead of formatting them
- plot None values as 0 so the bar chart still renders
- in inspector_cli, skip the comparison with a short message when
reference_output or run_output is missing
- return type of compare_results is now Dict[str,
List[Optional[float]]], which is what it actually returns

### Test plan

Added test_compare_results_with_non_tensor_output in
devtools/inspector/tests/inspector_utils_test.py. It calls
compare_results with a tensor output and an int output, with plot on and
off. It fails on main with the TypeError above and passes with this
change. The rest of inspector_utils_test.py passes (90 tests). ufmt and
flake8 are clean with the versions from requirements-lintrunner.txt.


cc @Gasoonjia @nil-is-all

Author: u7k4rs6

devtools/inspector/_inspector_utils.py

@@ -402,8 +402,10 @@ def plot_metric(result: List[float], metric_name: str):
     plt.clf()
     plt.figure(figsize=(8, 6))
 
-    x_axis = np.arange(len(result))
-    bars = plt.bar(x_axis, result, width=0.5)
+    # Non-tensor outputs have no metric value (None); plot them as 0.
+    values = [v if v is not None else 0.0 for v in result]
+    x_axis = np.arange(len(values))
+    bars = plt.bar(x_axis, values, width=0.5)
     plt.grid(True, which="major", axis="y")
     num_ticks = len(x_axis) if len(x_axis) > 5 else 5
     interval = 1 if num_ticks < 20 else 5
@@ -422,8 +424,8 @@ def plot_metric(result: List[float], metric_name: str):
             va="bottom",
         )
 
-    max_value = max(result) * 1.25
-    min_value = min(result) * 1.25
+    max_value = max(values, default=0.0) * 1.25
+    min_value = min(values, default=0.0) * 1.25
 
     # Cosine similarity has range [-1, 1], so we set y-axis limits accordingly.
     if metric_name == "cosine_similarity":
@@ -514,7 +516,7 @@ def compare_results(
     run_output: ProgramOutput,
     metrics: Optional[List[str]] = None,
     plot: bool = False,
-) -> Dict[str, List[float]]:
+) -> Dict[str, List[Optional[float]]]:
     """
     Compares the results of two runs and returns a dictionary of metric names -> lists of metric values. This list matches
     the reference output & run output lists, so essentially we compare each pair of values in those two lists.
@@ -546,7 +548,10 @@ def compare_results(
                 print(supported_metric)
                 print("-" * 20)
                 for index, value in enumerate(result):
-                    print(f"{index:<5}{value:>8.5f}")
+                    if value is None:
+                        print(f"{index:<5}{'N/A':>8}")
+                    else:
+                        print(f"{index:<5}{value:>8.5f}")
                 print("\n")
 
     return results

devtools/inspector/inspector_cli.py

@@ -64,12 +64,20 @@ def main() -> None:
         inspector.save_data_to_tsv(args.tsv_path)
     if args.compare_results:
         for event_block in inspector.event_blocks:
-            if event_block.name == "Execute":
-                compare_results(
-                    reference_output=event_block.reference_output,
-                    run_output=event_block.run_output,
-                    plot=True,
+            if event_block.name != "Execute":
+                continue
+            if event_block.reference_output is None or event_block.run_output is None:
+                print(
+                    "Skipping --compare_results: no reference output for this run. "
+                    "Pass --etrecord_path for an ETRecord that holds reference outputs "
+                    "(e.g. generated from a BundledProgram) and an ETDump with run outputs."
                 )
+                continue
+            compare_results(
+                reference_output=event_block.reference_output,
+                run_output=event_block.run_output,
+                plot=True,
+            )
 
 
 if __name__ == "__main__":

devtools/inspector/tests/inspector_utils_test.py

@@ -30,6 +30,7 @@
     calculate_mse,
     calculate_snr,
     calculate_time_scale_factor,
+    compare_results,
     convert_to_float_tensor,
     create_debug_handle_to_op_node_mapping,
     EDGE_DIALECT_GRAPH_KEY,
@@ -229,6 +230,22 @@ def test_compare_results_uint8(self):
         self.assertGreater(calculate_snr([a], [b])[0], 30.0)
         self.assertAlmostEqual(calculate_cosine_similarity([a], [b])[0], 1.0)
 
+    def test_compare_results_with_non_tensor_output(self):
+        # Non-tensor outputs (e.g. ints) have no metric value and must not
+        # break printing or plotting.
+        import matplotlib
+
+        matplotlib.use("Agg")
+        a = torch.rand(4, 4)
+        b = a.clone()
+        b[0, 0] += 1e-2
+        for plot in (False, True):
+            results = compare_results([a, 3], [b, 3], plot=plot)
+            for values in results.values():
+                self.assertEqual(len(values), 2)
+                self.assertIsNotNone(values[0])
+                self.assertIsNone(values[1])
+
     def test_merge_overlapping_debug_handles_basic(self):
         big_tensor = torch.rand(100, 100)
         intermediate_outputs = {