{"id":"39a8372d-918f-4cea-9e84-41277e349426","arxiv_id":"2505.15304","paper_version":2,"verdict":"CONDITIONAL","confidence":"MODERATE","novelty_score":6.0,"correctness_risk":"medium","formal_verification":"none","parameter_count":4,"one_line_summary":"A saliency-weighted quantization-aware training method lets 4-bit quantized imitation-learning policies match full-precision success rates across robot manipulation, driving, and control benchmarks.","lead":"This paper introduces SQIL, a training method that quantizes robot control policies to 4-bit precision while using saliency-weighted losses to preserve decisions at critical moments. The method recovers nearly full-precision success rates in simulation and real robot tests, with 2.5x to 3.7x speedups and energy savings on edge hardware.","discovery_kind":"new_method","skeptic_critique":{"model":"deepseek-v4-flash","headline":"Deployment-model ambiguity: Table 9's INT4 OpenVLA may exclude or differently quantize the SQIL LoRA adapters, so the reported success rates and efficiency may not be measured on the same model.","rationale":"The reader's weakest assumption—that SIS computed from the FP policy marks the states where quantization errors cause failures—is a real methodological gap, but the paper's empirical success does not logically require that premise to be true: even if SIS weighting is imperfect, QAT+QRD could still recover much of the FP performance, and the ablation in Table 1 shows SIS vs. KF weighting changes success by only 0.6–1.1 percentage points. The claim that would be false if the deployment ambiguity is resolved unfavorably is the paper's headline quantitative claim itself. If Table 9's 4-bit model is not the same model evaluated for accuracy, then no experiment in the paper demonstrates that SQIL achieves 2.5× speedup while maintaining within-1% success. This is not an accusation of inconsistency; it is a missing detail that determines whether the central claim is supported. The concrete test above (re-evaluate the exact deployed artifact) would settle it. Other issues highlighted by the reader (single-shot efficiency, no code release, small real-world trials) remain valid but secondary. The verdict should remain CONDITIONAL, with an explicit condition that the authors clarify and re-measure the deployed model.","tokens_in":19177,"tokens_out":11681,"duration_ms":99992,"concrete_test":"Ask the authors to disclose the deployment recipe for Table 9's INT4 OpenVLA: are the 110M LoRA adapters merged into the base weights and quantized to INT4, kept as FP16 adapters, or omitted? Then run the LIBERO success-rate evaluation on that exact deployed artifact (the same weight files used for the latency/energy measurement), and report memory including any adapter storage. If the adapters are omitted, re-run with them included; if they are merged+quantized, verify whether the success rate remains within 1% of the FP baseline. A direct computational check: compare the INT4 model's action outputs before vs. after merging the LoRA adapters on the LIBERO validation set; any non-trivial mismatch confirms the deployment model differs from the evaluated model.","verdict_should_be":"CONDITIONAL","load_bearing_attack":"The central claim—SQIL achieves a 2–4× speedup and energy savings while staying within 1% of the FP success rate—requires the accuracy and efficiency numbers to describe the same deployed policy. The paper leaves this unresolved. Accuracy tables (Tables 3–5, Figs. 7–8) are obtained from models fine-tuned with QLoRA, which trains 110M LoRA adapter parameters in BF16 on top of a frozen 4-bit base (Sec. 5.1, Supp. 1.2). Table 9 reports an 'INT4' OpenVLA on the Jetson AGX Orin with 4.0 GB memory and 2.5× speedup; at ~7.4B total parameters (LLM + ViT encoders), the entire weight set fits in the reported memory only if the LoRA adapters are not separately stored in BF16. The paper never states whether, at deployment, the LoRA weights are (a) dropped, (b) kept as separate BF16 adapters alongside the 4-bit base, or (c) merged into the base weights and then quantized to INT4. In case (a), the deployed model is not the SQIL policy whose success rates are reported; in case (b), the memory/latency/energy figures undercount adapter overhead and the model is not truly 4-bit; in case (c), the final merged-and-quantized weights were not trained under QAT, so the LIBERO success rates reported for the QLoRA configuration may not transfer to the deployed model. Without specifying the deployment recipe and re-evaluating the exact artifact used in Table 9, the headline claim couples measurements from two potentially different models.","agreement_with_reader":"partial"},"referee_report":{"model":"deepseek-v4-flash","summary":"The paper proposes SQIL (Saliency-Aware Quantized Imitation Learning), a fine-tuning scheme for 4-bit quantized imitation-learning policies. Given a full-precision (FP) policy and the expert dataset, SQIL computes a per-state saliency score SIS (Eq. 5) by averaging the L2 change in the policy's action under local patch perturbation (Eq. 4), then fine-tunes a quantized policy with a combined loss (Eq. 7): a behavior-cloning QAT term (Eq. 3) plus a quantization-robust action distillation term (Eq. 6) that up-weights high-SIS states by a factor beta. The method is evaluated on OpenVLA over the four LIBERO suites and two UR5 real-world setups, on CILRS over the NoCrash benchmark, on D4RL/MuJoCo control tasks, and on Jetson AGX Orin / RTX 2080 Ti hardware (Tables 8-9). The central claims are that SQIL recovers FP success rates within about one point on LIBERO (73.2 vs 73.8 on average) and enables 2-4x speedups and energy savings, with the mechanism attributed to suppressing quantization-induced action errors at mission-critical states.","tokens_in":19578,"tokens_out":16695,"duration_ms":144120,"significance":"If the result holds, SQIL is a practically attractive addition to IL pipelines: it reuses the existing expert dataset and FP policy, adds only a one-time SIS computation, and consistently improves over PTQ and plain QAT across manipulation, driving, and control domains. The paper's empirical breadth is a genuine strength: four LIBERO suites, NoCrash town/weather generalization, D4RL control, and real-world UR5 trials are all reported with repeated evaluation rounds, and the supplementary material discloses several ablations (Supp. Tables 10-14) including the unfavorable QRD-alone result and hyperparameter sensitivity. The main caveats, discussed below, concern the unspecified deployment recipe behind the hardware tables and an over-broad wording of the 'consistent recovery' claim; both are addressable without changing the method. The paper would also be strengthened by a code or data release, which is currently absent.","major_comments":[{"comment":"The hardware claims in Table 9 are not tied to the model whose accuracy is reported. All OpenVLA accuracy numbers come from models fine-tuned with QLoRA (Supp. 1.2), where the 4-bit base is frozen and only 110M LoRA adapter parameters are trained in BF16. Table 9 reports an 'INT4' OpenVLA with 4.0 GB memory and 2.5x speedup, but the paper never states whether the adapters at deployment are (a) dropped, (b) kept as separate BF16 weights, or (c) merged into the base and re-quantized to INT4. In case (a) the deployed model is the AWQ-initialized base, whose LIBERO-Spatial success rate is 80.1% (Table 3), well below the reported SQIL values; in case (b) the deployed model is mixed-precision (7.6B x 0.5 bytes is about 3.8 GB plus roughly 0.22 GB of BF16 adapters, which is arithmetically consistent with the reported 4.0 GB), so the '4-bit weight-quantized' label is inaccurate; in case (c) the final merged-and-quantized weights were not the ones trained under QAT, so the success rates in Tables 3-5 may not transfer to the deployed artifact. The authors should specify the deployment recipe and, if adapters are merged and re-quantized, re-evaluate success rate on the exact artifact used in Table 9.","section":"Section 5.4, Table 9; Supplementary Section 1.2"},{"comment":"The claims that SQIL 'consistently recovers full-precision performance' and 'maintains a success rate within 1% of the FP baseline' are stronger than several reported cells justify. On LIBERO, the per-suite SQIL-versus-FP gaps are 0.1, 0.4, 0.3, and 1.5 points (Table 3), so the 'within 1%' phrasing fails for LIBERO-Long (49.2 vs 50.7) even though it holds for the suite average (73.2 vs 73.8). The real-world trials also show gaps of 2-3 points (Figs. 7-8: 52.5% vs 55% and 76.7% vs 78.9%). More notably, Table 6 shows SQIL at 72% versus FP at 80% success on the new-town/dense (nt) condition of NoCrash, and the average across the four condition rows is 73 vs 76; this is better described as 'comparable' than as 'recovering'. Table 7 additionally shows a 44-point gap on Finger Spin (640 vs 684). I recommend restricting the 'within 1%' and 'recovering' wording to the LIBERO suite averages, or discussing the per-condition gaps and their statistical significance given the stated three-round protocol.","section":"Abstract and Section 1 (Contributions), vs. Tables 3, 6, 7 and Figs. 7-8"},{"comment":"The mechanistic claims are only partially supported. First, the paper's premise that high-SIS states computed from the FP policy (Eq. 5) coincide with the states where quantization errors cause failures is never tested directly; a concrete check would be to report the per-state overlap or rank correlation between SIS and the action discrepancy between the FP policy and the PTQ/QAT policies along successful episodes, using data already available for Fig. 1. Second, Supp. Table 10 shows that QRD alone degrades success from its own AWQ initialization (69.5% vs 80.1%), so the two loss terms are strongly non-additive; the main text's Section 4.4 'synergy' discussion would be more informative if it presented the QRD-alone cell and explained why selective distillation helps only in combination with L_QAT. Third, there is no ablation with uniform weighting (beta = 1, i.e., alpha_t = 1) to isolate the effect of the SIS selection itself; Table 1 compares SIS against keyframes but not against unweighted distillation with the same total loss.","section":"Sections 4.1-4.2 and 4.4; Supplementary Tables 10, 13"}],"minor_comments":[{"comment":"Typos and wording: 'LIBIERO' in the Table 3 header, 'IN4' for INT4 in Section 5.2.2, 'the the LIBERO' in Section 5.1, 'Autonomus Driving' in Supp. Section 1.1, 'wih' in Supp. Section 1.2, and 'adaptor' should be 'adapter' throughout.","section":"Throughout"},{"comment":"Algorithm 1 says 'Update pi_Q with partial LSQIL / partial theta' as if all weights are updated, but Supp. Section 1.2 states that QLoRA freezes the quantized base and updates only the 110M LoRA adapters; the main text should make this explicit so the reader does not misunderstand the QAT procedure.","section":"Algorithm 1 and Section 5.1"},{"comment":"Table 5 is captioned 'INT4 quantization results for pi0 with OpenVLA', but pi0 is introduced as a distinct compact model; please clarify pi0's training and quantization protocol (initialization, fine-tuning data, number of seeds) so that its rows can be compared with the OpenVLA rows.","section":"Section 5.2.2, Table 5"},{"comment":"Please state explicitly how the reported means and standard deviations are computed (e.g., 3 rounds of 500 episodes) and whether adjacent values such as 83.9 vs 84.0 in Table 3 are within the metric's noise; this would strengthen the 'within 1%' quantitative claim.","section":"Tables 3 and 10"},{"comment":"The 'QRD' row should state whether the SIS weighting alpha_t is applied in that ablation; as defined by Eq. (6), QRD always includes alpha_t, but the row is presented as if QRD were the plain, unweighted distillation term.","section":"Supplementary Table 10"},{"comment":"No code, data, or model-release statement is provided; given that the headline hardware numbers depend on toolchain details (TensorRT for the vision encoder and MLC-LLM for the LLM backbone), releasing the deployment script and the SIS evaluation code would materially improve reproducibility.","section":"Data availability"}],"recommendation":"major_revision","confidential_remarks":"The paper frames itself as the first systematic study of quantized IL, but LPPD (Ref. [37]) is closely related and is used as a baseline; the novelty framing should be calibrated during revision. The OpenVLA deployment story also deserves scrutiny at the toolchain level: if MLC-LLM is used for the backbone without native LoRA support, the adapter handling at inference determines whether the reported INT4 latency is even achievable, so the editor may want to request the evaluation code. I would also ask the authors to provide the QRD-alone configuration details, since a distillation loss that is 10 points below its own initialization is surprising and indicates a delicate interaction with the QAT term."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"Short version: this paper is worth refereeing, but the headline is over-sold. The core observation — quantization errors in imitation-learned policies mostly manifest at a few mission-critical states, and weighting those states in a QAT+distillation loss helps — is real, and the cross-domain evaluation is more thorough than most quantization papers. But \"within 1% of FP\" is not what the tables show, and the efficiency numbers in Table 9 may describe a different model than the accuracy numbers in Tables 3–5.\n\nWhat's new: the SIS criterion and selective QRD on top of standard QAT. The components aren't new, but the combination is, and the paper shows it works across OpenVLA/LIBERO, CILRS/NoCrash, and D4RL with consistent improvements over PTQ and QAT. The ablations (β, p, noise type) and the saliency visualizations give a reasonably coherent mechanistic story. Credit where due: the QRD-alone ablation in Table 10 shows QRD without QAT hurts (69.5 vs 80.9 on LIBERO-Spatial), and the paper does not hide it; the synergy claim is at least honest. Citation pattern looks fair — QAT/KD and LPPD are acknowledged.\n\nSoft spots, in rough order of severity. First, the deployment claim is under-specified. Accuracy comes from QLoRA fine-tuning, which trains BF16 LoRA adapters on top of a frozen 4-bit base (Supp. 1.2). Table 9 reports 4.0 GB memory and 2.5× speedup for \"INT4\" OpenVLA, but never states whether the LoRA adapters are dropped, kept separate, or merged and quantized at deployment. Those three options give you three different models. If the adapters are dropped, the efficiency numbers are for a policy whose success rate was never measured. If kept in BF16, the memory figure is wrong. This is the kind of ambiguity a referee must catch before acceptance.\n\nSecond, the \"within 1%\" claim fails in the paper's own tables. On LIBERO-Long, SQIL (AWQ) is 49.2 vs FP 50.7 — 1.5 points off, and with QuaRot it's 49.4 vs 50.7. On NoCrash, SQIL W4A4 is 72 vs FP 80 for the new-town/training-weather combination, and the driving score is 74 vs 80. So \"consistently recovering full-precision performance\" overstates the results. The average across LIBERO suites is within 1%, but the claim is made per-domain.\n\nThird, no code or data. For an empirical systems paper with large models and multiple benchmarks, that is a reproducibility risk, though not fatal. Fourth, real-world trials are small (10–30 per task), so those numbers are suggestive rather than statistically decisive.\n\nBottom line: the method is sensible, the evaluation is broad, and the central comparison probably holds up. But the authors need to specify the exact deployed model and correct the over-claiming before this is publishable as-is. Send it to peer review; a competent referee will have a clear job to do.","headline":"Worth refereeing, but the paper over-sells its own numbers: the 'within 1%' claim fails on LIBERO-Long and NoCrash, and Table 9 never says what happens to the LoRA adapters at deployment.","tokens_in":20099,"tokens_out":4450,"would_cite":true,"duration_ms":37581,"reading_group":"maybe","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":[],"pacs":[],"model":"deepseek-v4-flash","headline":"SQIL recovers full-precision performance in 4-bit quantized imitation policies by weighting training loss toward states where the full-precision policy is most sensitive to perturbation.","keywords":["quantization-aware training","imitation learning","vision-language-action models","robotic manipulation","model compression","saliency-based state importance","autonomous driving","edge deployment"],"falsifier":"Run the SQIL pipeline but replace the SIS-weighted QRD loss with a uniform QRD loss (all α_t = 1) at the same total loss weight; if the uniform version matches SQIL's success rate on LIBERO (within 0.5 percentage points), the saliency selection is not doing the claimed work. Alternatively, measure Spearman correlation between SIS values assigned by the FP policy and the per-state action discrepancy $\\|\\pi^Q(s_t) - \\pi^{FP}(s_t)\\|_2$ of an INT4 model; a correlation near zero would directly contradict the paper's mechanism.","tokens_in":19008,"feed_emoji":"🤖","tokens_out":9171,"duration_ms":69364,"temperature":0.7,"pith_summary":"Most quantization methods treat every timestep of an imitation-learned policy equally, but this paper observes that quantization error in robot policies is concentrated at a handful of mission-critical moments, such as the instant a gripper grasps an object. The authors propose SQIL, which uses a saliency-based state importance score (SIS) to identify those moments from the full-precision policy, then upweights a distillation loss at those states during 4-bit quantization-aware training. The reported result is that quantized vision-language-action models, driving policies, and physics-control policies all recover full-precision success rates within about one percentage point, while running two to four times faster with large energy savings on edge hardware. A reader should care because large imitation-learned policies are otherwise too slow and memory-heavy to deploy on battery-powered robots.","feed_headline":"4-bit robot policies match full-precision control","feed_subtitle":"Loss weighting focuses training on mission-critical states, cutting energy up to 2.5x on edge GPUs.","key_machinery":"The machinery has two parts. The first is the saliency-based state importance score (SIS), defined as $SIS(\\pi^{FP}, s_t) = \\mathbb{E}_k \\left[ \\tfrac{1}{2} \\|\\pi^{FP}(s_t) - \\pi^{FP}(\\phi(s_t,k))\\|_2^2 \\right]$, where $\\phi(s_t,k)$ perturbates the state locally (a Gaussian blur over image patch $k$); it identifies states where the full-precision policy's action is highly sensitive to local visual changes. The second is quantization-robust action distillation (QRD), $L_{QRD} = \\alpha_t \\, \\mathbb{E}_\\tau \\left[ \\frac{1}{|T_i|} \\sum_{s_t \\in \\tau_i} D(\\pi^Q(s_t), \\pi^{FP}(s_t)) \\right]$, with $\\alpha_t = \\beta$ if $SIS > T$ and $\\alpha_t = 1$ otherwise, $D$ an L2 discrepancy, $\\beta=2$, and $T$ the top-20% SIS threshold. The two parts work together: QAT keeps the quantized policy faithful to expert data, QRD shapes the quantized policy's action distribution toward the FP teacher, and the SIS weighting concentrates the shaping at the states where divergence would be fatal.","core_discovery":"The paper's central claim is that quantization error in imitation learning is sparse in time rather than uniform: across most timesteps a 4-bit policy deviates only slightly from its full-precision teacher, but at a few mission-critical states—typically fine-grained physical interactions like grasping, releasing, or inserting—the action discrepancy spikes and causes the whole episode to fail. SQIL detects these states with a saliency-based state importance score (SIS), the average over image patches of the squared action change of the full-precision policy under local Gaussian perturbation, and then applies a quantization-robust action distillation (QRD) term that weights the teacher-student action discrepancy by an extra factor (β=2) at the top 20% of salient states, added to the standard QAT cross-entropy loss. With only this added weighting, the paper reports that INT4 weight-quantized OpenVLA matches the full-precision 73.8% success rate on LIBERO at 73.2%, INT4 W4A4 CILRS recovers FP driving success on NoCrash-dense (80% vs 82% in the easiest condition), and D4RL MuJoCo returns come within a few points of FP while LPPD-style 4-bit policies lose substantially. The authors further show the same fixed hyperparameters work across robot manipulation, autonomous driving, physics simulation, and real-world UR5 deployments, and that the method also applies to the π0 flow-matching policy.","pith_inferences":["The same SIS weighting could be applied to other robustness interventions beyond quantization, such as pruning masks, data augmentation, or regularization of the FP policy itself; the paper's key mechanistic claim is that IL losses should be state-importance-weighted, not that quantization is the only error source.","One testable extension is an online SIS variant that recomputes saliency from the quantized policy during training; the quantized policy's own fragility points might differ from the FP teacher's, and updating the weights could improve recovery at very low bitwidths (INT2/INT3).","If the sparse-error observation generalizes, then episode success rate is a more appropriate metric for quantized IL than mean squared action error over all timesteps; a model with low average error can still fail catastrophically at a single critical state.","The finding that quantizing the LLM backbone (not the vision encoder) drives most of the performance loss suggests that future VLA quantization should focus saliency computation on language-conditioned reasoning rather than purely visual patches."],"forward_implications":["INT4 weight quantization of OpenVLA-class VLA policies becomes practical on edge GPUs: 2.5× speedup, 2.5× energy savings, 4× memory reduction at success rates within 1% of full precision.","The same recipe—SIS-weighted distillation on top of QAT—restores full-precision behavior for weight+activation 4-bit driving policies (CILRS), yielding 3.7× speedup and 3.1× energy savings on a low-end GPU.","Because the hyperparameters (β=2, top-20% threshold, L2 discrepancy) transfer across manipulation, driving, and physics control, SQIL can serve as a drop-in modification to existing QAT fine-tuning pipelines for IL policies.","SQIL recovers the full-precision policy's visual attention at critical states (lower saliency divergence in Table 2), implying the quantized model reasons about the same task-relevant regions as the teacher."],"supporting_citations":[{"why":"OpenVLA, the 7.6B vision-language-action model that the paper quantizes; its QAT-only fine-tuning leaves a measurable success-rate gap that SQIL closes.","marker":"[27]"},{"why":"LIBERO benchmark provides the task suites and expert demonstration datasets for manipulation evaluation.","marker":"[35]"},{"why":"AWQ is the weight quantizer used as the PTQ baseline and the initialization point for QAT and SQIL on OpenVLA.","marker":"[34]"},{"why":"LSQ supplies learned step-size quantization for the W4A4 driving and physics policy experiments.","marker":"[12]"},{"why":"CILRS is the end-to-end driving policy model used to test SQIL under weight+activation quantization.","marker":"[57]"},{"why":"NoCrash-dense benchmark supplies the driving success-rate and driving-score metrics across towns and weather conditions.","marker":"[8]"},{"why":"D4RL supplies the MuJoCo continuous-control tasks and datasets for the physics simulation experiments.","marker":"[17]"},{"why":"LPPD is the prior low-precision policy distillation baseline that SQIL outperforms on MuJoCo tasks.","marker":"[37]"},{"why":"Keyframe-based state importance baseline that SIS outperforms by 1.1% on LIBERO.","marker":"[28]"},{"why":"Perturbation-based saliency method that motivates the SIS definition in Equation 4.","marker":"[18]"}],"fun_headline_variants":["Saliency-aware 4-bit imitation learning matches full precision","4-bit robot policies recover full-precision success via saliency weighting","Quantized imitation learning: focus on key states to cut energy 2.5x","Edge GPUs run 4-bit policies without losing decision accuracy","Saliency-based loss weighting enables 4-bit robot control at 2.5x speedup"],"cache_read_input_tokens":3200,"weakest_assumption_plain":"The approach assumes that the full-precision policy's action sensitivity to small visual perturbations marks the same states where the quantized policy's errors actually cause failures; if the correlation between SIS and quantization-induced action error is weak or reversed, the selective weighting would emphasize the wrong timesteps.","fun_headline_variants_meta":{"raw":{"variants":["Saliency-aware 4-bit imitation learning matches full precision","4-bit robot policies recover full-precision success via saliency weighting","Quantized imitation learning: focus on key states to cut energy 2.5x","Edge GPUs run 4-bit policies without losing decision accuracy","Saliency-based loss weighting enables 4-bit robot control at 2.5x speedup"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000304,"raw_usage":{"total_tokens":1791,"prompt_tokens":1036,"completion_tokens":755,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":652,"completion_tokens_details":{"reasoning_tokens":657}},"tokens_in":652,"tokens_out":755,"duration_ms":6173,"temperature":1.0,"reasoning_tokens":657,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-07T15:20:04.974697+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Run the SQIL pipeline but replace the SIS-weighted QRD loss with a uniform QRD loss (all α_t = 1) at the same total loss weight; if the uniform version matches SQIL's success rate on LIBERO (within 0.5 percentage points), the saliency selection is not doing the claimed work. Alternatively, measure Spearman correlation between SIS values assigned by the FP policy and the per-state action discrepancy $\\|\\pi^Q(s_t) - \\pi^{FP}(s_t)\\|_2$ of an INT4 model; a correlation near zero would directly contradict the paper's mechanism.","supporting_citations":[{"cited_title":"Libero: Benchmarking knowl- edge transfer for lifelong robot learning","cited_arxiv_id":null,"evidence_quote":"LIBERO benchmark provides the task suites and expert demonstration datasets for manipulation evaluation."},{"cited_title":"Awq: Activation-aware weight quan- tization for llm compression and acceleration","cited_arxiv_id":null,"evidence_quote":"AWQ is the weight quantizer used as the PTQ baseline and the initialization point for QAT and SQIL on OpenVLA."},{"cited_title":"Learned step size quantization","cited_arxiv_id":null,"evidence_quote":"LSQ supplies learned step-size quantization for the W4A4 driving and physics policy experiments."},{"cited_title":"End-to-end urban driving by imitat- ing a reinforcement learning coach","cited_arxiv_id":null,"evidence_quote":"CILRS is the end-to-end driving policy model used to test SQIL under weight+activation quantization."},{"cited_title":"Exploring the limitations of behavior cloning for autonomous driving","cited_arxiv_id":null,"evidence_quote":"NoCrash-dense benchmark supplies the driving success-rate and driving-score metrics across towns and weather conditions."},{"cited_title":"Low Precision Policy Distillation with Application to Low-Power, Real-time Sensation-Cognition-Action Loop with Neuromorphic Computing","cited_arxiv_id":"1809.09260","evidence_quote":"LPPD is the prior low-precision policy distillation baseline that SQIL outperforms on MuJoCo tasks."},{"cited_title":"Kisa: A unified keyframe identifier and skill annotator for long-horizon robotics demonstrations","cited_arxiv_id":null,"evidence_quote":"Keyframe-based state importance baseline that SIS outperforms by 1.1% on LIBERO."},{"cited_title":"Visualizing and understanding atari agents","cited_arxiv_id":null,"evidence_quote":"Perturbation-based saliency method that motivates the SIS definition in Equation 4."}],"review_version":1}