Figures tracked via LFS, rewording

Signed-off-by: Eliot Heinrich <eheinrich@nvidia.com>

Author: eliotheinrich

.gitattributes

@@ -1 +1,2 @@
 *.onnx filter=lfs diff=lfs merge=lfs -text
+assets/**/*.png filter=lfs diff=lfs merge=lfs -text

assets/docs/relaybp_gamma_ensemble_perf.png

@@ -3,9 +3,9 @@
 Improving Relay BP Decoding With Gamma Ensembles
 =================================================
 
-The NV-qLDPC Relay BP decoder supports ensembles of independent gamma distribution trajectories (N "lanes"), run in parallel on a single GPU. When any lane has satisfied the stopping criterion, then the decoder may exit early. This can lead to significantly improved decoding decoding performance as increased parallelism allows for faster exploration of decoding solutions, and therefore lower latency for hard-to-decode syndromes which may stall Relay BP. 
+The NV-qLDPC Relay BP decoder supports ensembles of independent gamma distribution trajectories (N "lanes"), run in parallel on a single GPU. When any lane has satisfied the stopping criterion, then the decoder may exit early. This can lead to significantly improved decoding performance as increased parallelism allows for faster exploration of decoding solutions, and therefore lower latency for hard-to-decode syndromes which may stall Relay BP. 
 
-While setting multiple lanes of ensembled gammas can reduce the number of Relay BP iterations needed to converge to a solution, it can also lead to increased time per iteration; each leg of Relay BP synchronizes between lanes to check for convergence. Multiple lanes share a fixed GPU allocation, so as the number of edges in the Tanner graph increases, the GPU eventually must serialize the execution of each lane at each iteration, and then block for every lane to complete. These competing effects offset each other to some extent, so the mean latency per iteration may or may not be lower than the un-ensembled mean latency. However, the main benefit of ensembling is that the decoder can accept the minimum number of iterations to converge over some lanes, which means that slow-converging lanes are less likely to dominate the overall decoding time. Thereforre, the distribution of decode latencies becomes narrower. This can in turn lead to substantially improved LER under hard deadline constraints, where decoding failures are dominated by deadline misses. We will see below examples of bivariate-bicycle codes (BB) seeing up to 50-90x improved logical error rate, depending on the code and deadline.
+While setting multiple lanes of ensembled gammas can reduce the number of Relay BP iterations needed to converge to a solution, it can also lead to increased time per iteration; each leg of Relay BP synchronizes between lanes to check for convergence. Multiple lanes share a fixed GPU allocation, so as the number of edges in the Tanner graph increases, the GPU eventually must serialize the execution of each lane at each iteration, and then block for every lane to complete. These competing effects offset each other to some extent, so the mean latency per iteration may or may not be lower than the un-ensembled mean latency. However, the main benefit of ensembling is that the decoder can accept the fastest converging lane, and terminate slow-converging lanes early. The slow-converging lanes then do not contribute to the overall decoding time, narrowing the distribution of decode latencies. This can in turn lead to substantially improved LER under hard deadline constraints, where decoding failures are dominated by deadline misses on slow decodes. We will see below examples of bivariate-bicycle codes (BB) seeing up to 50-90x improved logical error rate, depending on the code and deadline.
 
 The first experiment we perform is to investigate the competing effects of reducing the mean number of iterations to converge versus increasing the time per iteration; we build the Z-component of the circuit-level detector error model (DEM) (i.e. the Z-stabilizer detectors only) for the bivariate-bicycle (BB) codes ``[[72,12,6]]``, ``[[144,12,12]]`` and ``[[288,12,18]]`` and, for each, construct the decoder with ``gamma_ensemble_size`` set to N in {1, 2, 4, 8}. We then decode many sampled syndromes, timing each ``decode()`` call and reading back the number of Relay BP iterations the decoder used to converge:
 
@@ -73,7 +73,7 @@ All experiments below use the same circuit-level noise and decoder settings, and
    * - ``stopping_criterion``
      - ``FirstConv``
 
-.. image:: ../../images/relaybp_gamma_ensemble_perf.png
+.. image:: ../../../../assets/docs/relaybp_gamma_ensemble_perf.png
    :align: center
    :alt: Iterations to converge, time per iteration, and mean latency versus ensemble size, for several DEMs
 
@@ -84,7 +84,7 @@ Latency Distribution
 
 One of the benefits of ensembling is that the latency distribution becomes narrower, leading to more consistent latency for hard-to-decode syndromes. Using the same decoders as above, we now focus on the behavior of the 50th percentile, 90th percentile, and 99th percentile decoding latencies.
 
-.. image:: ../../images/relaybp_latency_percentiles.png
+.. image:: ../../../../assets/docs/relaybp_latency_percentiles.png
    :align: center
    :alt: Latency percentiles (p50, p90, p99.9, p99.99) versus ensemble size N, per code
 
@@ -95,13 +95,13 @@ Logical Error Rate Under Hard Deadlines
 
 The narrower tail can improve logical error rates considerably for decoders under hard deadlines. Suppose each decode must finish within a wall-clock budget ``t``; a decode is a success only if it both finishes within ``t`` and returns the correct logical outcome, so the logical error rate under that deadline is ``LER(t) = P(latency > t or logical error)``. Using the same decoders as above, we record both the per-syndrome latency and whether the decoded logical is correct. The plot below shows the LER versus deadline for un-ensembled Relay BP (i.e. N = 1) and for each ensemble size N; each curve is measured over 150,000 sampled syndromes per configuration at the circuit-level noise strength given above (``p = 0.002``), using the ``FirstConv`` stopping criterion.
 
-.. image:: ../../images/relaybp_hard_deadline_ler.png
+.. image:: ../../../../assets/docs/relaybp_hard_deadline_ler.png
    :align: center
    :alt: Deadline vs LER — bicycle codes
 
 Ensembling contracts the latency tail for all three codes, resulting in substantially lower LER for certain deadlines: beyond a crossover at the tightest deadlines (where the higher per-iteration cost makes the larger ensembles slightly worse), a larger ensemble misses fewer deadlines at looser budgets and reaches a lower floor. The regime under which ensembling is beneficial for these codes depends on the code and deadline, and likely requires specific tuning based on the problem. Below is a plot of the factor by which each ensemble size lowers LER relative to un-ensembled Relay BP as a function of the deadline ``t``; values above 1 mean a lower LER than N = 1. 
 
-.. image:: ../../images/relaybp_ler_multiplier.png
+.. image:: ../../../../assets/docs/relaybp_ler_multiplier.png
    :align: center
    :alt: LER improvement multiplier over un-ensembled Relay BP versus hard deadline, per code