{"id":"c048c000-883f-4a63-93cc-e57f589eae09","arxiv_id":"2502.08690","paper_version":1,"verdict":"CONDITIONAL","confidence":"MODERATE","novelty_score":6.0,"correctness_risk":"medium","formal_verification":"none","parameter_count":4,"one_line_summary":"Skrr skips and reuses sub-layers of the T5 text encoder in text-to-image models, cutting memory by roughly 36% at about 42% sparsity while keeping FID and CLIP scores near the dense model.","lead":"This paper introduces Skrr, a method that prunes layers from the text encoder of text-to-image models and reuses neighboring layers to save memory while keeping image quality. If the results hold, it offers a practical way to cut the memory footprint of large T2I systems by about a third.","discovery_kind":"new_method","skeptic_critique":{"model":"deepseek-v4-flash","headline":"Hyperparameters were selected using the evaluation benchmarks (Table 3, Table A13), so the reported advantage over baselines may reflect test-set overfitting rather than a genuine property of Skrr; a held-out evaluation is required.","rationale":"The reader's weakest assumption concerned the calibration prompt distribution being a reliable proxy for target image quality. That is a valid generalization concern, but the reported experiments already evaluated on MS-COCO and GenEval, which differ from the 150-250 token CC12M calibration set, and the method still performed well on those benchmarks. The more immediate threat to the central claim is that the method's own hyperparameters—beam size and projection module—were selected using the same benchmarks that are used to demonstrate superiority. Table 3 and Table A13 show this selection explicitly. As a result, the evaluation is not independent of the design choices, and the magnitude of the reported gains over baselines is uncertain. This is a methodological issue that can be settled by a held-out evaluation with fixed hyperparameters, so the appropriate verdict remains conditional rather than rejection.","tokens_in":28670,"tokens_out":5162,"duration_ms":55119,"concrete_test":"Re-run the full Skrr pipeline with a beam size fixed before any evaluation, for example k=1 (greedy), and with the projection module enabled as a default, on a benchmark not used in any ablation (e.g., T2I-CompBench or a held-out split of MS-COCO). Compare against ShortGPT, LaCo, and FinerCut using the same held-out benchmark. If Skrr with the fixed configuration no longer matches or exceeds the baselines, then the reported advantage in Table 1 is not robust to hyperparameter choice and the central claim is not established.","verdict_should_be":"CONDITIONAL","load_bearing_attack":"The central claim is that Skrr outperforms existing blockwise pruning methods at high sparsity while preserving image quality. This claim rests on the reported numbers in Table 1, but the design of Skrr was not fixed before looking at those benchmarks. In the main text, the beam size is selected by 'we selected the optimal beam size k = 3' based on Table 3, which evaluates CLIP, DreamSim, and GenEval on the same MS-COCO subset and full GenEval set used in the final evaluation. Similarly, the inclusion of the projection module is justified post hoc via Table A13, which reports the same CLIP/DreamSim/GenEval metrics. Because these benchmarks were used both to tune the method and to report final results, there is no unbiased estimate of how Skrr would perform with a fixed configuration. The baselines were also tuned, but the central comparative claim is affected: if a different beam size or no projection module had been chosen a priori, the margin over FinerCut and other baselines at 41.9% sparsity might shrink or disappear. The paper does not provide error bars, code, or a held-out evaluation, so the magnitude of this optimism is unknown. This is not a claim of fraud; it is a standard concern about selection on the test set, and it directly threatens the reliability of the stated 'state-of-the-art' result.","agreement_with_reader":"partial"},"referee_report":{"model":"deepseek-v4-flash","summary":"This paper presents Skrr, a two-stage blockwise pruning method for the T5-XXL text encoder in text-to-image diffusion models. In the Skip stage, sub-blocks (MHA and FFN) are pruned in an order found by beam search that minimizes an MSE discrepancy between the dense and pruned projected text embeddings, plus a null-condition discrepancy term. In the Re-use stage, each skipped sub-block is replaced by an adjacent kept sub-block if that reduces the discrepancy. The authors report quantitative results on PixArt-Σ at sparsity levels around 24-42%, showing that Skrr maintains or improves FID, keeps CLIP and DreamSim close to dense, and degrades GenEval less than ShortGPT, LaCo, and FinerCut. Qualitative results on Stable Diffusion 3 and FLUX.1-dev are also shown. The paper includes ablations for the beam size, the projection module, and the Re-use component, as well as a theoretical error-bound analysis.","tokens_in":28905,"tokens_out":10523,"duration_ms":87367,"significance":"The problem is well-motivated: text encoders account for a large fraction of parameters and memory in T2I pipelines while contributing little FLOPs, and dedicated text-encoder pruning is under-explored. The proposed method is simple and the empirical results at high sparsity, if taken at face value, would be a practical improvement over existing blockwise pruning methods. The paper ships extensive ablations and qualitative comparisons, and the design choices (projection-aware discrepancy, null-condition term) are task-appropriate. However, the credibility of the central claim is currently limited by the use of the evaluation benchmarks for hyperparameter selection and by the narrow quantitative scope (one base model).","major_comments":[{"comment":"The hyperparameters of Skrr (beam size k and the inclusion of the projection module) are selected using the same evaluation benchmarks that are reported as final results in Table 1. Specifically, Table 3 selects k = 3 by comparing CLIP, DreamSim, and GenEval on the MS-COCO validation subset and the full GenEval set, and Table A13 justifies the projection module on the same metrics. This makes the final comparison subject to selection on the test set. The concern is not hypothetical: the projection module ablation changes GenEval from 0.381 to 0.442 at 41.9% sparsity, which is most of the reported margin over FinerCut (0.442 vs. 0.367). The authors should provide a held-out validation set for hyperparameter tuning, or at least report the full comparison for all k values and with projection disabled, so that the central claim is not affected by this selection.","section":"Section 4.3, Table 3; Appendix C.5, Table A13"},{"comment":"The quantitative comparison against baselines is performed only on PixArt-Σ. The results for SD3 and FLUX.1-dev are qualitative (Figure 5) and the computational-cost comparison in Appendix C.2 does not include image-quality metrics. Since the abstract claims 'state-of-the-art' performance and the method is presented as generally applicable to T2I text encoders, at least one quantitative benchmark (e.g., GenEval or CLIP score) on a second model is needed to support the generality of the central claim.","section":"Section 4.1, Table 1; Section 4.2, Figure 5"},{"comment":"The calibration set consists exclusively of prompts with 150–250 tokens sampled from CC12M, while the GenEval evaluation prompts are short (typically one or two objects). The discrepancy metric in Eq. (3) is computed on these long calibrated prompts, and the paper does not verify that the resulting block ranking transfers to short prompts. Although the GenEval numbers in Table 1 are positive, a robustness experiment with a short-prompt calibration set (or a mixed-length set) would substantially strengthen the claim that the pruning mask is tailored to T2I rather than to the calibration distribution.","section":"Appendix B.3"}],"minor_comments":[{"comment":"The percentages in Figure 1(a) appear inconsistent with the text: the figure seems to attribute about 3.25% of FLOPs to the text encoders, while the text states they contribute less than 0.5%. Please correct the figure or the text.","section":"Section 1, Figure 1(a)"},{"comment":"The paragraph on FinerCut metrics is internally contradictory: it first says MSE outperforms cosine similarity, then says cosine similarity yielded better performance, and then states the MSE-based implementation was used as the baseline. Please clarify which configuration is used and why.","section":"Appendix C.6"},{"comment":"The conclusion mentions a 'Skrr dot product' as one of three key components, but the paper's metric is MSE (Eq. (3)); please fix this terminology.","section":"Conclusion"},{"comment":"There is an algebraic typo in the recurrence for E3: the term M2||θ1 − θ̂1|| should be M2||θ2 − θ̂2||. The final telescoped bound is correct, but the displayed step is not.","section":"Appendix A.1, Eq. (A15)"},{"comment":"No error bars or confidence intervals are reported for the main metrics; given the relatively small differences between methods (e.g., CLIP 0.312 vs. 0.308 in Table 1), error bars or multiple seeds would help assess significance.","section":"General"},{"comment":"The condition ||θi − θ∗i || < ||θi|| is not verified on the actual models; the authors should state whether it holds for the reused blocks reported in Tables A4–A6.","section":"Section 3.2, Theorem 3.2"}],"recommendation":"major_revision","confidential_remarks":"The paper is within the scope of the journal and the core idea is promising, but the evaluation protocol allows selection on the test set through the choice of k and the projection module. I recommend asking for a held-out validation evaluation or an ablation-inclusive main table, and for at least one additional quantitative result on a second model. The theoretical section is not a blocker, but it should be tidied up."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"Short version: this is a good empirical paper, not a good theory paper. The empirical recipe — skip text-encoder sub-blocks using a beam search over a T2I-specific discrepancy (projected embedding MSE plus a null-condition term), then re-use adjacent sub-blocks — is new and it works. At 41.9% T5-XXL sparsity on PixArt-Sigma it cuts pipeline memory from 10.18 to 6.46 GB, roughly 36%, while keeping CLIP at 0.312 vs 0.314 dense and FID at 19.93 vs 22.89. It beats ShortGPT, LaCo, and FinerCut on almost every metric at comparable sparsity, and the qualitative results look consistent. The authors also show Re-use plugs into ShortGPT and FinerCut, which is a nice generality check. Credit where due: the ablations are thorough, the null-condition discrepancy is a sensible T2I-specific addition, and the Limitations appendix is honest that performance degrades at high sparsity.\n\nThe soft spots are real but not fatal. Lemma 3.1's proof has algebraic errors in the intermediate recurrences (the E3 line uses the wrong index and misplaces a factor of (1+L2)), though the final bound is correct. More importantly, Theorem 3.2 is a tautology: it says if the reused weights are closer to the original than zero, the error bound is tighter. True by definition, but it does not establish that reusing an adjacent block satisfies that condition. The paper overstates this as 'theoretical support.' The empirical support is what carries the paper.\n\nThe bigger concern is test-set tuning. The beam size k=3 is selected from Table 3 using the same MS-COCO/GenEval metrics as the final evaluation, and the projection module is justified post hoc via Table A13 on the same metrics. There are no error bars and no code/data release. I checked whether this undermines the headline comparison: even at k=1 (greedy) Skrr beats FinerCut on CLIP, DreamSim, and GenEval, and the no-projection variant still beats FinerCut overall. So the advantage is probably not purely an artifact of the tuned hyperparameters, but the magnitude of the reported margins is likely optimistic. A held-out evaluation or nested hyperparameter selection would settle this.\n\nThe abstract's 'without compromising performance' is a bit strong — GenEval drops from 0.539 to 0.442 (about 18% relative) at the highest sparsity, and the authors acknowledge this in the Limitations.\n\nBottom line: this deserves a serious referee. Anyone deploying T2I models on memory-limited hardware will get value from the method, and the main claim should survive closer scrutiny. Recommend peer review with requested revisions: fix or remove the theory, add error bars or multiple seeds, release code, and report hyperparameter selection honestly.","headline":"Solid empirical pruning recipe for T2I text encoders with consistent gains over baselines; the theory is weak and hyperparameters were tuned on the evaluation benchmarks, but the main result likely survives.","tokens_in":29514,"tokens_out":4310,"would_cite":true,"duration_ms":40965,"reading_group":"yes","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":[],"pacs":[],"model":"deepseek-v4-flash","headline":"Skrr prunes text-to-image text encoders to roughly 42% sparsity and cuts pipeline memory by a third while holding image quality.","keywords":["text-to-image diffusion","text encoder pruning","blockwise pruning","layer reuse","memory efficiency","beam search","classifier-free guidance","T5-XXL compression"],"falsifier":"Generate two pruning masks with the Skip phase, one from the paper's long-prompt calibration set and one from a short-prompt set in the style of GenEval, then evaluate both pruned models on both prompt distributions; if the long-prompt mask wins on long prompts but clearly loses on short prompts, or if either mask's discrepancy score stays low while its images degrade, the proxy assumption is refuted. A second check is to reproduce the claimed guidance mechanism by perturbing the dense model's null embedding and asking whether FID improves to the same 19.93-class value across several seeds without touching the text encoder.","tokens_in":28386,"feed_emoji":"✂️","tokens_out":14965,"duration_ms":127270,"temperature":0.7,"pith_summary":"The paper claims that the text encoder is the hidden memory hog in text-to-image (T2I) diffusion models: it is invoked once per prompt, yet it holds the bulk of the parameters, while the denoising network that runs many iterations uses comparatively little memory. Skrr ('Skip and Re-use layers') is a training-free pruning recipe for that encoder. A beam search decides which attention and feed-forward sub-blocks to drop, scoring each candidate by the mean-squared change it causes in the projected text embedding that the denoiser actually conditions on, measured for both the prompt and the null condition used in classifier-free guidance. A second stage fills each removed slot with the hidden state of a neighbouring surviving block, and a Lipschitz bound (Theorem 3.2) shows this re-use is strictly safer than leaving the slot empty. On PixArt-Sigma at 41.9% text-encoder sparsity the pipeline memory falls from 10.18 GB to 6.46 GB with FID 19.93 versus 22.89 dense, CLIP 0.312 versus 0.314, and GenEval 0.442 versus 0.539, beating the ShortGPT, LaCo, and FinerCut baselines at the same sparsity.","feed_headline":"Prune the text encoder, keep the images: Skrr cuts memory 37%","feed_subtitle":"By skipping and reusing transformer layers, the text encoder keeps image quality while cutting memory by over a third.","key_machinery":"The load-bearing object is the discrepancy score $D = D_{f_c} + D_{f_\\varnothing}$, where each term is the mean-squared error, in the denoising network's projected conditioning space, between the dense text encoder's output and the pruned encoder's output on a prompt ($f_c$) or on the null condition used for classifier-free guidance ($f_\\varnothing$). This score is what makes pruning decisions speak to final image quality instead of to text-embedding statistics. Around it sit two algorithms: Skip, a beam search that keeps the $k$ lowest-discrepancy pruning paths so that interactions between removed sub-blocks are accounted for, and Re-use, which for each skipped sub-block compares feeding it the previous or the next unskipped neighbour's hidden state and keeps whichever lowers $D$. The re-use choice is backed by a Lipschitz argument (Lemma 3.1) bounding the output gap between any two transformer copies, which yields Theorem 3.2: re-using is strictly better than zeroing whenever $\\|\\theta_i - \\theta_i^*\\| < \\|\\theta_i\\|$.","core_discovery":"On the paper's own terms, the discovery is that transformer sub-blocks inside T2I text encoders are redundant enough that about 40% of the encoder can be dropped or recycled with negligible loss of generation quality, while existing blockwise pruning methods designed for autoregressive LLMs degrade sharply at the same sparsity. Two design choices carry this. First, the pruning metric is computed on the projected condition vector the denoising network consumes, not on raw hidden states, and it includes the null input used for classifier-free guidance; the paper shows that cosine-similarity metrics miss large null-embedding norm shifts that visibly corrupt images. Second, after skipping, the paper re-routes each removed sub-block's input through a neighbouring remaining sub-block, and proves (Theorem 3.2, from a Lipschitz error bound on transformers) that such re-use gives a strictly tighter output error bound than skipping alone whenever the neighbour's parameters are closer to the original than zero is; empirically, re-use restores the prompt adherence that Skip alone loses.","pith_inferences":["If the null-embedding mechanism is right, text-encoder pruning is partly an accidental retuning of classifier-free guidance; a testable extension is to co-optimize the pruning mask and the guidance scale $w$ to harvest the FID gain without the CLIP and GenEval losses.","The calibration set contains only long captions (150-250 tokens), so the proxy is validated on one prompt distribution; short prompts and rare concepts may engage different sub-blocks, and a prompt-length-stratified calibration set would be a cheap stress test before deployment.","The skip-and-reuse pattern should transfer to any memory-bound, single-forward-pass encoder in a generative pipeline, such as CLIP conditioning in video or 3D generators, because the projection-metric trick only requires that the encoder output enter the rest of the network through a fixed linear map.","The paper reports quality deteriorating beyond 50% sparsity; stacking weight quantization on top, a combination it mentions but does not test, could push text-encoder memory below roughly one gigabyte and widen the practical deployment range."],"forward_implications":["At 41.9% text-encoder sparsity on PixArt-Sigma, the pipeline drops from 5.42B to 3.43B parameters and from 10.18 GB to 6.46 GB of memory, with FID 19.93 (dense 22.89), CLIP 0.312 (dense 0.314), and GenEval 0.442 (dense 0.539).","In the high-sparsity regime the LLM-oriented baselines lose most prompt alignment (GenEval overall falls to between 0.087 and 0.367) while Skrr holds 0.442, so the biggest separation happens exactly where blockwise pruning previously failed.","Re-use behaves as a plug-in: applied on top of ShortGPT or FinerCut pruning masks, it restores fidelity and dense-model alignment in the paper's ablations, suggesting the re-routing step can help other pruning methods without retraining.","Compressing all three text encoders of Stable Diffusion 3 (T5-XXL at 41.9%, CLIP-L and CLIP-G at roughly 30%) keeps GenEval at 0.579 versus 0.689 for the dense model, indicating the recipe generalizes to multi-encoder pipelines.","Pruning improves FID from 22.89 to 19.93 while slightly lowering CLIP and GenEval; the paper's null-embedding perturbation experiment (dense FID falls to 20.65 under small noise on the null condition) supports a guidance-like explanation for the fidelity gain."],"supporting_citations":[{"why":"ShortGPT supplies the blockwise-pruning baseline and the Block Influence scoring logic, plus the finding that transformer layers are highly redundant.","marker":"Men et al., 2024"},{"why":"LaCo supplies the layer-collapse baseline; its merging of adjacent layers is conceptually closest to Skrr's re-use step.","marker":"Yang et al., 2024"},{"why":"FinerCut supplies the sub-block-level pruning baseline with the MSE metric that Skrr adopts and extends, and the main sparsity-matched comparison.","marker":"Zhang et al., 2024"},{"why":"Defines T5-XXL, the text encoder whose redundant adjacent blocks are the object of the pruning analysis in Fig. 3.","marker":"Raffel et al., 2020"},{"why":"PixArt-Sigma is the primary testbed; its denoising projection module defines the space where the discrepancy metric is computed.","marker":"Chen et al., 2024"},{"why":"CC12M is the source of the 1k-prompt calibration set that drives the Skip and Re-use decisions.","marker":"Changpinyo et al., 2021"},{"why":"Classifier-free guidance defines the null condition whose embedding norm instability motivates the $D_{f_\\varnothing}$ term in the metric.","marker":"Ho & Salimans, 2021"},{"why":"Beam search is the search strategy that the Skip phase adapts to explore multiple pruning paths jointly.","marker":"Freitag & Al-Onaizan, 2017"},{"why":"GenEval is the object-focused alignment benchmark that most cleanly separates Skrr from the baselines at high sparsity.","marker":"Ghosh et al., 2024"}],"fun_headline_variants":["Skrr: Skip text encoder layers, cut memory 37%","Memory-hungry text encoders? Skrr skips layers, keeps quality","Skrr reuses text encoder layers: 37% less memory, same images","Skrr: Skip and reuse text encoder layers, memory cut 37%"],"cache_read_input_tokens":3200,"weakest_assumption_plain":"The method trusts a single proxy: that the mean-squared change in the projected text embedding, measured on a 1,000-prompt calibration set of long CC12M captions, reliably predicts whether final generated images will stay good on prompts that the set never contained.","fun_headline_variants_meta":{"raw":{"variants":["Skrr: Skip text encoder layers, cut memory 37%","Memory-hungry text encoders? Skrr skips layers, keeps quality","Skrr reuses text encoder layers: 37% less memory, same images","Skrr: Skip and reuse text encoder layers, memory cut 37%"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000928,"raw_usage":{"total_tokens":3986,"prompt_tokens":965,"completion_tokens":3021,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":581,"completion_tokens_details":{"reasoning_tokens":2938}},"tokens_in":581,"tokens_out":3021,"duration_ms":21977,"temperature":1.0,"reasoning_tokens":2938,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-08T04:57:53.339101+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Generate two pruning masks with the Skip phase, one from the paper's long-prompt calibration set and one from a short-prompt set in the style of GenEval, then evaluate both pruned models on both prompt distributions; if the long-prompt mask wins on long prompts but clearly loses on short prompts, or if either mask's discrepancy score stays low while its images degrade, the proxy assumption is refuted. A second check is to reproduce the claimed guidance mechanism by perturbing the dense model's null embedding and asking whether FID improves to the same 19.93-class value across several seeds without touching the text encoder.","supporting_citations":[],"review_version":1}