acceptodds
Under review as a conference paper at ICLR 2027

CodaCache: Coordinated Adaptive Branch Caching for Efficient Image-to-3D Generation

Abstract

Image-conditioned diffusion and flow models generate detailed 3D assets from a single image. Full classifier-free guidance (CFG) computes conditional and unconditional predictions at every denoising step, increasing generation cost. The effect of reusing one prediction depends on whether the other is recomputed or reused. In our Hunyuan3D 2.1 diagnostic, reusing both predictions yields a smaller deviation from Full CFG than reusing the conditional prediction while refreshing the unconditional one. At a fixed state and timestep, reuse errors with similar directions and magnitudes can partly offset each other in the CFG prediction. This paper proposes CodaCache, a training-free causal controller that adaptively coordinates CFG branches. It estimates the effects of omitting the unconditional prediction and reusing the conditional one from completed denoising history, using latent motion and time separation. It combines these estimates to choose Full CFG, conditional-only refresh, or conditional-only reuse before current branch evaluation, without extra denoiser calls. On TRELLIS.2 and Hunyuan3D 2.1 with Toys4K and an Objaverse-XL subset, CodaCache uses 37.6-44.7% of Full-CFG denoising FLOPs and achieves 2.34-2.73 end-to-end generation speedup, excluding offline calibration. Across valid outputs, mean Chamfer distance increases by at most 0.15% and mean F-score decreases by at most 0.10 percentage points relative to Full CFG.

Primary area:
generative models
Keywords:
Image-to-3D Generation, Inference Acceleration, Classifier-Free Guidance, Prediction Caching, Training-Free Acceleration

Reviews

Among:
Shape:
1234this paper, Top 30%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.67 over 3 reviews, above 70% of the others.
Reviewer_yGfROpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
1
Soundness
2
Read review
Paper summary

This paper proposes CodaCache, a training-free causal controller that adaptively coordinates CFG branches. It estimates the effects of omitting the unconditional prediction and reusing the conditional one from completed denoising history, using latent motion and time separation. It combines these estimates to choose Full CFG, conditional-only refresh, or conditional-only reuse before current branch evaluation, without extra denoiser calls.

Critical strengths

1、 Identifies and empirically validates nontrivial interactions between the two CFG branches during prediction reuse. 2、 Effectively reduces CFG-related network computation, accelerating 3D generation while maintaining average geometric quality close to that of full CFG.

Critical weaknesses

1、 The method primarily relies on heuristic, history-based error estimates, without theoretical bounds on the final geometric error or an explicit mechanism for controlling error accumulation. 2、 The comparisons primarily involve acceleration methods developed for image and video diffusion models, with relatively limited comparisons against methods specifically designed for 3D generation. 3、 The computational overhead of offline calibration and its impact on the overall acceleration benefits are not quantified.

Questions for authors

1、 Some errors are occurred in the pipeline figure, formulations cannot present, missing the details of the proposed structures. The paper presentation should be largely improved. 2、 The contributions of the proposed methods should be clarified and highlighted in the Introduction section. The paper writing should be improved. 3、 Some recent methods should be compared and discussed, such as: [1] Gen-3diffusion: Realistic image-to-3d generation via 2d & 3d diffusion synergy. [2] Ouroboros3d: Image-to-3d generation via 3d-aware recursive diffusion. [3] Rethinking Image-to-3D Generation with Sparse Queries: Efficiency, Capacity, and Input-View Bias. [4] GECO: Fast Generative Image-to-3D Within One SECOnd. [5] Cycle3d: High-quality and consistent image-to-3d generation via generation-reconstruction cycle. [6] Ultra3D: Efficient and High-Fidelity 3D Generation with Part Attention. 4、 Why the proposed method can achieve the better efficiency than other methods? The more detailed motivations and explanations should be provided.

6 comments
AuthorsOpenReview ↗

Response to W1, W3 and Q1

Thank you for your valuable and helpful comments.

W1

Thank you for your suggestion. Final geometry error needs to be analyzed across the complete generation process. We control error through step-by-step scoring and refreshes, and use measurements across several settings to assess the scoring mechanism and default parameters.

(1) Error passes through several interacting stages. Branch omission and prediction reuse change later denoising states and action choices. Their effects also pass through later denoising, decoding, and mesh extraction, so it is difficult to obtain a meaningful final geometry error bound from local history-based scores alone. At each step, CodaCache uses the cumulative latent changes and time separation since the corresponding observation or refresh to compute scores. It refreshes or returns to Full CFG when the acceptance conditions are not met.

(2) Checking the overall effect through final geometry. For the same set of Hunyuan3D objects, Figure 2(a) shows a mean CD of 0.0012 between CodaCache and Full CFG, compared with 0.0049–0.0271 for controls using preset branch-handling and refresh strategies. This shows that CodaCache retains a smaller geometry deviation after complete generation.

(3) Testing the scores and default parameters across several settings. CodaCache uses the same action threshold of 0.15 in all four settings across two models and two datasets. Compared with Full CFG, the mean CD over valid outputs increases by at most 0.15% in relative terms, and the mean F-score decreases by at most 0.10 percentage points (Table 1). The threshold and history-count experiments on Hunyuan3D 2.1/Toys4K in Appendix E, Table 12, further support the efficiency–quality tradeoff of the default settings. These results provide experimental evidence for scoring and parameter choices on the tested models and datasets.

We have explained trajectory feedback and the refresh mechanism in Section 4.3, “Causal execution, fallback, and fixed configuration,” of the revised manuscript. We have reported the final geometry results and the experimental evidence for parameter choices in Figure 2(a), Section 5.2 and Table 1, and Appendix E, Table 12.

W3

Thank you for your suggestion. We have added measurements of offline calibration time. Including the per-image share of calibration time, CodaCache still achieves a 2.38× speedup on TRELLIS.2/Toys4K.

SettingCalibration time allocated per image (s/image)Full CFG (s/image)CodaCache, excluding calibration (s/image)Speedup including calibration
TRELLIS.2/Toys4K0.02291.97820.80742.38×

Its efficiency is therefore ensured:

(1) Calibration is performed once, and its results are shared by later generations. Calibration is completed before inference. The resulting support intervals are fixed and used for later generation, with no need to repeat calibration for each image.

(2) Measuring calibration cost and its effect on speedup. The calibration time allocated to each image is 0.0229 seconds, about 1.2% of the Full CFG generation time per image. Including this cost, CodaCache takes 0.8303 seconds per image for calibration and generation combined.

We have added these measured times and their calculation details to the calibration-cost paragraph in Section 5.2 and the “FLOPs and generation time” paragraph in Appendix C of the revised manuscript.

Q1

Thank you for your suggestion. We have improved the explanation accompanying Figure 4 and clarified the basis of joint scoring and the controller's execution order.

(1) Clarifying the links between modules in the figure. The caption further explains how historical anchors, trajectory distances, and rates of change are used for scoring, how the image condition is used by the C branch, and how feedback from history is used for later decisions.

(2) Clarifying the joint scoring formula. We have explained why Eq. (5) combines two history-based scores on a common solver-increment scale, and how a shared threshold coordinates U omission and C reuse.

(3) Explaining the order of cache and feedback updates. We have stated that, when the old cache is available, F/P actions first observe the C-reuse error and then update the cache. Only valid rates of change update the estimates, and new observations are used for later decisions.

These changes appear in the Figure 4 caption, the text around Eq. (5) in Section 4.1, and the second paragraph of Section 4.3. The complete execution procedure and parameter settings are given in Tables 4 and 5 of Appendix B, respectively.

AuthorsOpenReview ↗

Response to W2&Q3 and Q2

W2&Q3

Thank you for your suggestion. We have added quantitative comparisons with seven methods and explained, one by one, how SparseGen, Cycle3D, and Ultra3D differ from our work and how they relate to the scope of comparisons in this revision.

We have compared three 3D generation methods (GECO, Gen-3Diffusion, and Ouroboros3D) and four training-free acceleration methods (Fast-SAM3D, LEAP, TeaCache, and EasyCache) on Toys4K, using the same evaluation setup as the main experiments. Full CFG and CodaCache are based on Hunyuan3D 2.1. All speedups are calculated relative to Full CFG in the table.

MethodCD ↓F-score (%) ↑Throughput (assets/s) ↑Speedup (×) ↑
Full CFG0.015975.360.18731.00
GECO0.025068.570.41762.23
Gen-3Diffusion0.019074.910.20221.08
Ouroboros3D0.024071.110.23031.23
Fast-SAM3D0.020175.160.42512.27
LEAP0.019775.100.41582.22
TeaCache0.019975.010.40452.16
EasyCache0.021474.730.42892.29
CodaCache0.015975.350.43832.34

In this setting, compared with the seven added methods, CodaCache achieves the highest throughput, the lowest mean CD over valid outputs, and the highest mean F-score. Compared with Full CFG, CodaCache achieves a 2.34× speedup, with the same reported mean CD of 0.0159 and a mean F-score decrease of 0.01 percentage points.

For the other three works, we explain how each design relates to CodaCache and the conditions for quantitative comparison in this revision.

(1) SparseGen uses learnable sparse 3D queries to generate a 3D Gaussian representation in one forward pass, improving efficiency through its output representation and network design. CodaCache keeps the existing representation and pretrained backbone, and accelerates generation by coordinating branch computation. SparseGen's current public configurations and weight links are for SRN Cars. We have not found weights for its open-category experiments in its public resources, so we discuss its method in this revision and have not included it in the cross-category mesh evaluation on Toys4K. Paper; official implementation.

(2) Cycle3D cycles through 2D generation, 3D reconstruction, and rendering during denoising to improve consistency across views. CodaCache uses trajectory history to decide when to omit U and reuse C. Cycle3D's loop depends on a specially trained reconstruction model. We have not found the corresponding weights in its official public resources, so we provide a comparison of mechanisms in this revision. Paper; official implementation.

(3) Ultra3D uses coarse and fine generation stages and part attention to reduce the cost of high-resolution generation by improving computation within the network. CodaCache reduces the number of branch evaluations during inference. Ultra3D's current official site provides a project showcase and an online demo. We have not found a model implementation and weights for local evaluation on the same hardware, so we discuss its method in this revision. Paper; official project.

We have added the design differences of these three methods to the first paragraph of Section 2, “Related Work,” in the revised manuscript. We have reported the setup and results of the added comparisons in the “Additional comparisons on Toys4K” paragraph and Table 9 of Appendix C.

Q2

Thank you for your suggestion. We have highlighted the following three contributions in the introduction to clarify the link from the branch-interaction observation to score design and then to acceleration results.

(1) Identifying interactions between branch treatments. Under the same refresh rule in Hunyuan3D, reusing C/U together produces geometry closer to Full CFG than reusing C while recomputing U.

(2) Proposing joint scoring based on trajectory history. We jointly assess the effects of U omission and C reuse on a common solver-increment scale, using a shared threshold to coordinate actions for the two branches.

(3) Proposing CodaCache, a training-free inference acceleration framework for image-to-3D generation. Across four settings with two models and two datasets, it achieves lower CFG denoising FLOPs, lower mean CD over valid outputs, and higher mean F-score than the acceleration methods compared in Table 1.

We have listed these contributions at the end of Section 1, “Introduction,” in the revised manuscript, under “Our contributions are as follows.”

AuthorsOpenReview ↗

Response to Q4

Q4

Thank you for your question. CodaCache reduces computation by reusing complete predictions and uses sample trajectories to choose when to reuse them. Compared with Full CFG, it reduces CFG denoising FLOPs by 55.3–62.4%. Across the four settings in Table 1, it uses fewer FLOPs and achieves better mean geometric quality over valid outputs than the compared acceleration methods. Specifically, it has two advantages:

(1) Reusing predictions directly to reduce branch computation. In the later denoising stages of Hunyuan3D, prediction directions change little between adjacent steps, suggesting that existing predictions can be reused across steps (Figure 1(b)). CodaCache provides three actions: F recomputes C and U, P recomputes only C, and R omits U and directly uses the cached C. Thus, R needs no branch evaluation at the current step. Table 3 shows that removing R increases CFG denoising FLOPs to 70.4–82.6% of Full CFG, showing the computation saved by reusing complete C predictions.

(2) Making decisions for each sample to choose when to reuse and when to refresh. The effect of reuse changes with the denoising stage and the treatment of the other branch (Figure 2(b) and Figure 3). CodaCache jointly scores U omission and C reuse using each sample's trajectory history, then selects the action with the fewest branch evaluations among those that meet the acceptance conditions.

Table 2 further shows the value of choosing when to reuse. On Hunyuan3D, increasing the fixed reuse count from r4 to r5/r6 reduces FLOPs but increases CD and lowers F-score. Compared with Fixed CodaCache-r2, CodaCache achieves lower mean CD over valid outputs and higher mean F-score in all four settings.

We have added this efficiency analysis to the second paragraph of Section 5.2 in the revised manuscript, which starts with “Two design choices account for these savings.” The action definitions are in Section 4.1, and the fixed-policy comparison and component ablation are in Tables 2 and 3, respectively.

We hope these explanations and experimental results address your questions.

Reviewer_nWRFOpenReview ↗
Rating
3
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

CodaCache is a training-free controller that selects full CFG, conditional-only evaluation, or conditional prediction reuse for image-to-3D generation. It combines history-based estimates of guidance-omission and reuse errors to choose actions before each denoising step.

Critical strengths
  • The controller is causal and requires no extra denoiser evaluations or weight updates.
  • Evaluation covers two backbones, two datasets, and a broad set of acceleration baselines.
  • Component ablations, same-state diagnostics, and cross-dataset calibration tests provide useful supporting evidence.
Critical weaknesses
  • TRELLIS.2’s released guidance defaults are overridden; comparisons against the native pipeline and tuned reduced-step sampling are missing.
  • Quality metrics use each method’s own valid-output subset. Common-success comparisons and failure rates for all baselines are needed.
  • Diagnostic action counts imply more branch evaluations than Separate acceptance, despite lower full-evaluation FLOPs; this discrepancy needs clearer accounting.
Questions for authors

How does CodaCache compare with TRELLIS.2’s released guidance defaults?

3 comments
AuthorsOpenReview ↗

Response to Reviewer nWRF

Thank you for your helpful feedback.

W1 To examine the effects of omitting and reusing CFG branches under a fixed number of sampling steps, we use linear Full CFG, which computes both conditional and unconditional predictions at every step, as a controlled reference. Accordingly, the TRELLIS.2 main experiments apply guidance over the full time interval and set guidance_rescale=0. Full CFG and CodaCache both retain eight solver updates per cascade level.

For comparison with the released default pipeline, we have added evaluations on TRELLIS.2/Toys4K using the official default 12/12-step configuration. We also evaluate reduced-step configurations with 6/6 and 4/4 steps that retain the official guidance settings. CodaCache achieves mean geometric quality over valid outputs close to that of our 8/8-step Full CFG reference. It also uses fewer FLOPs than both reduced-step configurations, with better geometric metrics and higher valid-output rates.

MethodStepsCD ↓F-score ↑Valid (%) ↑FLOPs (%) ↓Time (s/image) ↓
Full CFG8/80.0686054.8289.69100.001.9782
CodaCache8/80.0687054.8489.6543.800.8074
Official default sampling12/120.0653055.0289.81131.042.7610
Official guidance + reduced steps6/60.0726752.5388.5673.291.4298
Official guidance + reduced steps4/40.0759150.3782.1247.610.9218

The official 12/12-step configuration achieves a lower CD at a higher computational cost. Relative to this configuration, CodaCache reduces FLOPs by 66.58%, with a 5.21% increase in CD.

The 4/4-step configuration has a computational cost closer to CodaCache's. Relative to this configuration, CodaCache further reduces FLOPs by 8.00% and increases F-score by 4.47 percentage points. It also achieves a lower CD and a higher valid-output rate. CodaCache achieves better mean geometric quality with fewer FLOPs than either tested reduced-step configuration.

We have added this table to Appendix C of the revised manuscript (Table 7).

W2 We thank the reviewer for the suggestion. On TRELLIS.2/Toys4K, we have added an evaluation on the common-success set and failure-rate statistics for all compared methods. Within each run, CD and F-score are computed on the same set of inputs for which all methods produce valid outputs. Failure rates are calculated using the total number of attempted inputs as the denominator. The table below reports means across five runs.

MethodCommon-success CD ↓Common-success F-score ↑Failure rate (%) ↓
Full CFG0.068654.8210.31
Step AG0.078150.6710.69
Adaptive Guidance0.075253.0311.33
Limited-Interval0.077153.4110.84
THG0.070151.5611.16
TCFG0.075753.2210.44
StreamDiffusion R-CFG0.074553.1210.91
RSTR0.069852.4911.71
Fast3Dcache0.069354.1512.06
SenCache0.070953.1211.54
ResCa0.070553.8010.88
DPCache0.069953.5611.32
CodaCache0.068554.8110.35

On the common-success set, CodaCache achieves a lower mean CD and a higher mean F-score than all 11 acceleration baselines. Both mean geometric quality metrics remain close to those of Full CFG. Its failure rate is only 0.04 percentage points higher than Full CFG's and lower than those of all other acceleration baselines. In this setting, its advantage in mean geometric quality remains when all methods are evaluated on the same valid inputs. We have added this table (Table 8) and the corresponding evaluation protocol to Appendix C of the revised manuscript.

W3 The action counts in Appendix F correspond to 9,292 branch evaluations for CodaCache and 6,354 for Separate acceptance. The methods perform similar numbers of Full CFG actions, but CodaCache performs more conditional prediction refreshes. It therefore makes more branch evaluations in this diagnostic subset.

Appendix F uses 100 inputs and three paired seeds, whereas the FLOPs percentages reported in Table 3 (44.7% and 50.8%) are based on five runs of the full evaluation. These statistics come from different sets of runs, so the diagnostic counts cannot directly explain the FLOPs difference in the main table. Appendix F analyzes how joint scoring affects local action selection. Overall efficiency is measured independently in the full evaluation.

We have clarified the evaluation scope and purpose of each result in Section 5.4 and Appendix F.

Q1 We have added a comparison with the official default 12/12-step configuration on TRELLIS.2/Toys4K. The full results are reported in W1. Relative to this configuration, CodaCache reduces FLOPs by 66.58%, while mean CD increases by 5.21% and F-score decreases by 0.18 percentage points. These results show substantially lower computation with some loss in mean geometric quality relative to the official default.

Thank the authors for the additional experiments and response to my reviews. I keep my original rating.

AuthorsOpenReview ↗

Thank You for Your Response

We appreciate your time and constructive feedback, and hope that our additional results and clarifications have addressed your concerns.

Reviewer_ehQeOpenReview ↗
Rating
3(+1)
Confidence
4
Informativeness
1
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes CodaCache, a training-free inference acceleration method for image-to-3D diffusion models. It combines CFG branch pruning, conditional prediction caching, and trajectory-based error estimation to dynamically select between full CFG, conditional-only computation, and cached prediction reuse. Experiments on TRELLIS.2 and Hunyuan3D 2.1 demonstrate 2.34–2.73× speedup with minimal degradation in geometric quality.

Critical strengths
  1. The method achieves substantial inference acceleration while largely preserving geometric quality, demonstrating strong practical effectiveness.
  2. The experiments are comprehensive, covering multiple backbones, datasets, competitive baselines, and ablations that support the effectiveness of adaptive branch scheduling.
Critical weaknesses
  1. The methodological novelty is limited. The framework primarily combines established techniques, including CFG pruning, temporal caching, trajectory-based error estimation, and threshold-based scheduling, without introducing a fundamentally new acceleration mechanism.
  2. The proposed joint-error scoring lacks sufficient methodological justification. Although the paper motivates its approach through error cancellation between CFG branches, the actual controller simply adds two estimated errors without explicitly modeling their interaction. This disconnect weakens the central claimed contribution.
Questions for authors

Thank you for the comprehensive experiments and promising results. I have two main concerns:

  1. CodaCache appears to integrate established techniques from FasterCache, Fast3Dcache, and BAG. Could the authors clarify the fundamental methodological novelty beyond combining CFG pruning, temporal caching, and adaptive scheduling?
  2. The paper motivates its approach through error cancellation between CFG branches, yet the controller simply adds two scalar error estimates without modeling their interaction. Moreover, the extrapolated scores are not theoretically guaranteed to bound actual errors.

I would be appreciate if the authors further justify these design theoretically or empirically. And it would be better presenting a hand-writing method figure instead of current Figure 4.

7 comments
AuthorsOpenReview ↗

Response to Q1&W1 (Part 1)

Thank you for your valuable and helpful feedback.

Q1&W1

CodaCache uses the underlying concepts of Pruning, Cache Reuse, Error Estimation, and Scheduling. For image-to-3D generation, however, our improvement is to jointly consider "how the two CFG branches affect each other and how to optimize them," and to make separate choices based on each sample's actual denoising process. The key challenge is that an optimization action on C must also account for the effect of the optimization action on U. In addition, the same treatment may have different effects across samples and denoising stages. We explain the specific design differences in four aspects below.

1.1 Scheduling

CodaCache considers the effects of optimizing each branch together, so the controller needs to make a joint choice among the three complete actions F/P/R. Both approximations affect the current update, and the same action may affect different samples differently. The choice therefore needs to be made for each sample at each denoising step.

(1) Coarse-grained level

BAG uses a shared compute-or-reuse mask for the two CFG branches. CodaCache jointly decides whether and how to optimize U and C, which requires a joint choice among three complete actions. For example, whether C is suitable for reuse also depends on the effect of U, so the two choices need to be considered together.

Fast3Dcache combines token caching with a preset, fixed point for turning off CFG computation. CodaCache has three actions: F recomputes C/U, P omits U and recomputes C, and R omits U and reuses the complete cached C prediction. Based on cache conditions and each sample's historical scores, the controller selects the acceptable action that requires the fewest branch evaluations at the current step. For example, a higher U-omission score leaves less score margin for C reuse. When C reuse is not accepted, the controller recomputes C if U omission remains acceptable; otherwise, it refreshes both branches and returns to Full CFG.

(2) Fine-grained level

Applying the same optimization action at the same denoising step may have different effects on different samples. CodaCache therefore selects actions separately for each sample, rather than setting a common CFG-off step or reuse interval in advance.

During inference, each sample independently maintains its cache, historical observations, and online rates of change. The controller updates the scores using the latest Full-CFG observation, the C-refresh record, and the trajectory changes since those points, and decides which action to take at the current step.

Thus, under the same control parameters and acceptance threshold, different samples can still produce different action sequences. They separately determine when and at which step to apply each optimization to the two branches, and when to use Full CFG. This allows the allocation of branch computation to change with the sample and denoising stage.

1.2 Error Estimation

CodaCache estimates the individual effects of actions such as U omission and C reuse on the update, and also includes the trajectory changes jointly caused by these two treatments in earlier steps. This is because optimization actions such as pruning and reuse change later states and error observations, and the current decision needs to reflect these changes.

Our observations on Hunyuan3D show that, under the same C-refresh rule, reusing C while keeping newly computed U produces a larger geometric deviation from Full CFG than reusing C/U together. In other words, the effect of reusing one branch on the full CFG update depends on how the other branch is handled. Based on this observation, CodaCache makes use of this interaction by comparing candidate updates at the same state and using a common normalization scale, so that they can be used together for action selection.

At the same time, scores for pruning, reuse, and refresh are computed from each sample's actual inference trajectory. The controller combines online rates of change, changes in the latent state, and time intervals to update scores in real time. Earlier pruning, reuse, and refresh actions change each sample's later trajectory, cache refresh steps, and error observations. These changes then enter the two later scores through historical observations, online rates of change, and trajectory distances. CodaCache's error estimation can therefore distinguish the update changes caused by the current candidate actions and use trajectory information from earlier actions to guide joint action selection during inference.

AuthorsOpenReview ↗

Response to Q1&W1 (Part 2) and Q2&W2 (Part 1)

1.3 Pruning

Fast3Dcache omits later U computations after a preset CFG-off point, while CodaCache uses each sample's score to decide how to handle U at the current step. This is because the same treatment of U at the same step may affect different samples differently, which calls for a separate choice for each sample. FasterCache reduces inference computation by reusing attention features and reconstructing U from the current C and cached C/U differences. When CodaCache omits U, it directly uses the newly computed or cached complete C prediction to perform the update.

Based on each sample's actual denoising trajectory, the CodaCache controller estimates how optimizing the U branch affects the update: it omits U when the score meets the threshold and uses Full CFG otherwise. At later steps, it continues to make new decisions based on changes in that sample's trajectory and can return to Full CFG after omitting U. This choice for each sample allows U computation to be retained or omitted according to the actual inference process, balancing geometric accuracy and inference efficiency.

1.4 Cache Reuse

CodaCache uses each sample's joint score to decide whether to reuse or refresh C. This is because cache changes may differ across samples, and whether reuse is possible also depends on the effect of the U branch. For branch handling, BAG uses a shared compute-or-reuse mask for the two CFG branches. When U omission is allowed, CodaCache uses the current scores to either recompute C or reuse the complete cached C prediction.

The controller estimates the effect of reuse from each sample's cache history and actual trajectory, and considers it together with the U-branch score. It reuses C when the cache is valid, both scores are available, and their sum meets the threshold. For example, if the U-omission score meets the threshold but the C-reuse conditions are not met, it selects P and recomputes C. Cache reuse is therefore determined by the current estimated effect for each sample. The refresh timing changes with the actual denoising process and remains coordinated with pruning.

These method differences and design mechanisms correspond to the following locations in the main paper: method comparisons, the paragraphs on FasterCache, BAG, and Fast3Dcache in Section 2; actions and joint selection, Eqs. (4)–(6) in Section 4.1; historical observations and scores, Eqs. (7)–(13) in Section 4.2; execution and feedback, paragraphs 2–3 in Section 4.3.

Q2W2

Through feedback from actual trajectories, CodaCache implicitly accounts for the interaction between U omission and C reuse when computing �0��0� and �1��1�. Earlier pruning and reuse change later states, caches, and error observations. These changes enter the two scores, which are then used together through �2��2� to decide whether C can be further reused. We explain the calculation of the two scores, the basis for addition, and the measured results below.

2.1 Components of the joint score

The historical observations, rates of change, and trajectory distances used by the two scores all come from each sample's actual denoising process. Thus, for example, the effects of earlier U omission and C reuse enter the calculation of each score. When the validity and support conditions specified in the paper are met, the scores can be expanded as:

\begin{aligned} A_i={}&q_f^U+ \left[\mu_i^U+\kappa\operatorname{MAD}(\mathcal W_i^U)\right]D_{i\mid f},\ B_i={}& \left[\mu_i^C+\kappa\operatorname{MAD}(\mathcal W_i^C)\right]D_{i\mid j}. \end{aligned}

Here, �3��3� is the step of the latest valid Full-CFG observation before the current step, and �4��4� is the earlier step at which the current C cache was refreshed. �5��5� combines the accumulated relative changes in the latent state and the normalized time interval from the corresponding step to the current step. The terms in brackets contain the online mean of historical rates of change and a correction for recent variation. U observations compare Full-CFG updates with C-only updates at F steps; C observations compare updates from fresh C and the old cached C at refresh steps. Each comparison holds the state and solver history at that observation step fixed and uses a common normalization definition.

Specifically, in the completed history, whether U was omitted affects the observations at later C refreshes through the later states, and thus affects the rate of change used in �6��6�. Whether C was reused also affects the U-omission observations at later Full-CFG steps, and thus affects �7��7�. Historical actions also affect the timing of valid observations and cache refreshes, as well as the actual accumulated trajectory distance, thereby affecting �8��8�, �9��9�, and the corresponding �10��10�. This is how the effects of the two treatments enter the calculation of the two scores through feedback from actual trajectories.

AuthorsOpenReview ↗

Response to Q2&W2 (Part 2) and Q3

2.2 Additive design

Action R omits U and reuses C at the same time, so the effects of both approximations need to be considered together. CodaCache adds the two scores and uses one threshold to decide whether to accept R. Thus, at the same state, timestep, and solver history, let �0��0�, �1��1�, and �2��2� denote the update increments of the three candidate actions F, P, and R, respectively. Then:

dR−dF=(dP−dF)+(dR−dP).d_R-d_F=(d_P-d_F)+(d_R-d_P).

The two terms on the right correspond to the update changes from omitting U and then additionally reusing C. After common normalization, the triangle inequality shows that the true local error of R relative to F is at most the sum of these two true errors. This relation also holds when the two errors are related.

During inference, the controller obtains �3��3� and �4��4� from historical observations before computing the current branches. When the cache is valid and the scores are available and supported, it accepts R if �5��5�. This means that a higher U-omission score leaves less score margin for C reuse.

�6��6� and �7��7� come from historical estimates, and their sum is not necessarily an upper bound on the current true error. We therefore further check the effectiveness of its action choices using measured errors.

2.3 Measured results

The measurements support the joint rule's choice to refresh when each score meets the threshold but their sum is above it. In the Hunyuan3D 2.1/Toys4K diagnostic in Appendix F, we start from the same denoising state, keep the timestep and solver history fixed, and compute the updates for F, P, and R separately. Using F as the reference, we measure the local update errors of P and R on a common scale. If the two deviations cancel each other, this cancellation is also reflected in the measured error. At the states described above, the joint rule selects P, while Separate acceptance selects R. In Table 14(a), we subtract the error of R from the error of P at the same state. The medians of these paired differences are −0.0141 and −0.0309 for the CodaCache and Separate acceptance trajectory sources, respectively.

The error statistics for the actions actually accepted also support the effectiveness of the joint rule's decisions. Table 13(b) shows that, in this diagnostic, all 3658 P actions and 2525 R actions accepted by CodaCache had measured local update errors at most 0.15. Among the 5470 R actions accepted by Separate acceptance, 275 had errors above this threshold.

The score construction and joint selection rule are described in Sections 4.1–4.3 of the main paper and Appendices B.2–B.3. The measured results are in Section 5.4 of the main paper and Tables 13 and 14 in Appendix F.

Q3

Thank you for your suggestions. We have improved the explanation accompanying Figure 4 and added detail on the basis for joint scoring and the controller's execution order.

(1) We clarified the links between the modules in the figure. The caption further explains how historical anchors, trajectory distances, and rates of change are used for scoring, how the image condition is used by the C branch, and how historical feedback is used for later decisions.

(2) We added detail to the explanation of the joint score formula. We explain the basis for combining the two historical scores on a common solver-update scale in Eq. (5), and how the shared threshold coordinates U omission and C reuse.

(3) We clarified the order of cache and feedback updates. When an old cache is available, F/P actions first measure the C-reuse error and then update the cache. Only valid rates of change update the estimates, and the new observations are used for later decisions.

These changes are in the caption of Figure 4, the text around Eq. (5) in Section 4.1, and the second paragraph of Section 4.3. The complete execution procedure and parameter settings are in Tables 4 and 5 of Appendix B, respectively.

We hope these explanations address your questions.

Comments on the paper

1 comment
AuthorsOpenReview ↗

Thank You to the Reviewers and Area Chair

Dear Reviewers and Area Chair,

First, we thank you for your careful review, continued discussion, and valuable time. The reviewers' suggestions have been very valuable to our work on CodaCache.

During this discussion phase, we further clarified CodaCache's methodological contributions and how it differs from prior work. We further clarified our finding that the two branches in image-to-3D models affect each other. We explained how this finding led to our per-sample joint scheduling mechanism. In response to questions about joint error scoring and error accumulation, we explained the basis for additive scoring and the relationship between historical estimates and measured errors. We explained how trajectory feedback and refresh mechanisms inform later decisions. We also added explanations of why reusing complete predictions and selecting actions for each sample can improve efficiency. We also explained the sources of the efficiency gains and improved the figures and the presentation of the controller's execution flow. We clarified the scope of the statistics used in local diagnostics and the full evaluation.

Following the reviewers' suggestions, we added quantitative comparisons with three 3D generation methods and four training-free acceleration methods. CodaCache achieved higher throughput and better mean geometric metrics than these methods. On TRELLIS.2/Toys4K, we added comparisons with the official default configuration and two configurations with fewer sampling steps. The results show that CodaCache maintained better geometric quality and valid-output rates while requiring less computation than the tested configurations with fewer steps. In addition, we added an evaluation on the common-success set and failure-rate statistics. When all methods were evaluated on the same set of inputs with valid outputs, CodaCache still achieved better mean geometric metrics than the original acceleration baselines. These metrics remained close to those of the Full CFG reference. We also added measurements of the time required for offline calibration. After including the allocated calibration cost at this evaluation scale, CodaCache still achieved a 2.38× speedup.

Finally, we thank the reviewers again for recognizing the value of our work. We also thank the Area Chair and all reviewers for the valuable time they have devoted to the review and discussion. We hope our responses and additional experiments address your questions.

Sincerely,

The Authors

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.