{"id":"18566f7a-8659-4805-851c-789f2b861435","arxiv_id":"2504.13296","paper_version":2,"verdict":"CONDITIONAL","confidence":"MODERATE","novelty_score":5.0,"correctness_risk":"medium","formal_verification":"none","parameter_count":1,"one_line_summary":"Component-aware dependency graphs that isolate modules and inter-module flows produce finer pruning groups and gentler performance loss on a TD-MPC control task than vanilla dependency-graph pruning.","lead":"The authors introduce a pruning strategy that treats each module of a multi-component neural network, and the links between modules, as separate units to be pruned. Tested on a control task, it shows gentler performance loss at higher sparsity than standard dependency-graph pruning.","discovery_kind":"extension","skeptic_critique":{"model":"deepseek-v4-flash","headline":"The only performance comparison is confounded: encoder protection is applied to the proposed method but not to the vanilla baseline, so Fig. 2 cannot support the claim that smaller groups cause the reduced degradation.","rationale":"The reader's weakest assumption identified the unproven dimension-compatibility assertion in Section 4.6. That is a genuine implementation risk, but the more load-bearing weakness is the uncontrolled comparison in the only performance experiment. The paper's own text reveals that encoder protection was used only in the component-aware evaluation, so the measured performance gap may reflect a privileged component rather than the proposed graph partition. This does not require rejecting the method; it requires a controlled ablation. The verdict remains conditional: the method is plausible and the group-size statistics are internally consistent, but the central empirical claim is not yet established. A controlled re-run with matched encoder protection and error bars would settle the concern. The shape-consistency issue should also be addressed in the same revision, ideally by releasing code that shows how per-component and interface groups are kept disjoint with respect to boundary layers.","tokens_in":8108,"tokens_out":7673,"duration_ms":77853,"concrete_test":"Re-run the TD-MPC experiment with a controlled baseline: apply the identical encoder-protection weighting (the same importance multiplier on encoder-associated groups) to the vanilla DepGraph baseline, run at least 5 seeds at sparsity levels from 5% to 80%, and report means with error bars. If the protected-vanilla curve approaches the component-aware curve, the reported advantage is attributable to encoder protection rather than smaller groups. If it remains well below, the confound is not the explanation and the component-aware grouping claim gains support.","verdict_should_be":"UNCHANGED","load_bearing_attack":"The central empirical claim rests on the TD-MPC experiment in Section 5. The paper reports that the component-aware method 'exhibited a much more graceful and gradual decline' than the vanilla dependency-graph baseline, and attributes this to smaller, targeted pruning groups. However, the same section states that the result was 'demonstrated by assigning higher importance weighting to groups associated with the encoder in the TD-MPC model.' No equivalent encoder-protection mechanism is reported for the vanilla baseline. Since TD-MPC's downstream components consume encoder outputs, protecting the encoder alone could explain much of the performance gap at high sparsity, independent of group granularity. The comparison therefore conflates two variables: component-aware grouping and manual encoder protection. As written, Figure 2 does not establish that the proposed grouping strategy is what conserves functional integrity; it may simply reflect a protected encoder. The reader's shape-consistency concern about Section 4.6 is real but secondary; the empirical confound is the most direct threat to the paper's headline claim.","agreement_with_reader":"partial"},"referee_report":{"model":"deepseek-v4-flash","summary":"The paper proposes a component-aware structured pruning method for multi-component neural architectures (MCNAs). It extends the DepGraph dependency model by defining intra-component and inter-component interface dependencies (Eqs. (1)-(5)), extracting pruning groups within components and separate interface groups, and allowing users to protect sensitive components. Experiments on synthetic architectures report group counts and average group sizes; a TD-MPC cartpole-swingup experiment compares the method against vanilla dependency-graph pruning. The paper claims that the resulting smaller, targeted groups reduce performance degradation and achieve greater sparsity.","tokens_in":8252,"tokens_out":8936,"duration_ms":72053,"significance":"If the central empirical claim were established, the method would be a useful, low-cost extension of DepGraph for modular models such as TD-MPC and JEPA, where coarse dependency groups are a genuine practical problem. The dependency criteria in Eqs. (1)-(5) are clearly stated, and the synthetic group-size statistics serve as a reasonable software verification. However, the only performance evidence is confounded by unequal encoder treatment, and the group-size gains are largely definitional rather than evidence of functional preservation. The contribution is therefore a promising idea with insufficient validation in its current form.","major_comments":[{"comment":"The central empirical comparison is confounded. The component-aware results are obtained by assigning higher importance weighting to groups associated with the encoder, as stated in the last paragraph of Section 5, but no equivalent encoder protection or weighting is reported for the vanilla dependency-graph baseline. Since the downstream TD-MPC components consume encoder outputs, protecting the encoder alone could explain the much more graceful decline at high sparsity, independent of group granularity. As written, Figure 2 does not support the abstract's claim that component-aware grouping conserves functional integrity. Please rerun the baseline under identical encoder protection and report the number of seeds and error bars.","section":"See Section 5 and Figure 2."},{"comment":"The claim that per-component isolation prevents an infeasible change of dimensions between connected components is asserted rather than demonstrated. If component-internal pruning groups and interface groups are pruned independently, the pruned output dimension of one component can mismatch the pruned input dimension of its successor; shape matching is described only as a verification tool for dependency detection, not as a synchronization mechanism for pruning decisions. The paper should either prove that the grouping construction preserves dimensional compatibility or specify an explicit synchronization step, because this is the foundation of the functional-integrity claim.","section":"See Section 4.6."},{"comment":"The synthetic experiments show only that component-aware grouping produces more groups with smaller average size, which is a direct consequence of splitting at component boundaries and does not by itself validate the method. No task performance, accuracy, or functional-integrity metric is reported for the Simple, Branched, Multi-Path, Recursive, TDMPC-Style, or Complex CNN models, so Table 1 demonstrates the bookkeeping of the grouping algorithm but not the paper's central claim that smaller groups reduce performance degradation.","section":"See Section 5 and Table 1."}],"minor_comments":[{"comment":"The formal definition of DX(i,j) only contains 1[Ci != Cj] ^ d1(i,j), while the explanation refers to designated input/output interfaces C+ and C-; the interface conditions should appear in the equation or d1 should be defined to include them.","section":"See Section 4.3, Eq. (4)."},{"comment":"The figure reports reward curves without error bars, seed count, or run count; please add them or state explicitly that the plot shows a single run.","section":"See Figure 2."},{"comment":"The entry (4(2), 36->1) for the TDMPC-Style model is unclear; please define the notation, in particular the meaning of the parenthesized number.","section":"See Table 1."},{"comment":"There are typographical errors in the references, such as Boosting runed networks (Qian et al.) and Prodccedings (Jiang et al.); a careful proofread is needed.","section":"See the reference list."},{"comment":"The text refers to model.named children and model.named modules; use code formatting and clarify whether these are PyTorch's named_children() and named_modules().","section":"See Section 4.5."},{"comment":"The TD-MPC training and evaluation details, such as optimizer, learning rate, environment steps, and number of evaluation episodes, are omitted; please provide them so the experiment is reproducible.","section":"See Section 5."}],"recommendation":"major_revision","confidential_remarks":"The manuscript is at an early stage and the TD-MPC experiment is the main obstacle to publication; a matched-baseline comparison with multiple seeds and a justification of dimension consistency would address the core concern. I do not see a novelty disclosure issue, but the paper would benefit from more substantial validation before it can support the abstract's strong claims."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"Short version: the paper has a plausible and genuinely new idea—explicitly partitioning dependency graphs at component boundaries—but the empirical support is much weaker than the abstract suggests. The only performance comparison is confounded, and the dimension-consistency mechanism is asserted rather than shown.\n\nWhat's new: DepGraph merges layers into coarse groups across the whole network. This paper formalizes intra-component dependencies (DI) and inter-component interface dependencies (DX), and it isolates cross-component flows as separate groups. That is a legitimate extension, and Table 1 shows the method produces smaller groups as intended. If the idea holds up, it's useful for pruning modular models like TD-MPC that have encoders, world models, and policies.\n\nThe soft spots are real, and one is load-bearing. Section 5 reports that the TD-MPC result was \"demonstrated by assigning higher importance weighting to groups associated with the encoder.\" There is no indication the vanilla baseline got the same protection. Since TD-MPC's downstream components consume encoder outputs, protecting the encoder alone could explain much of the gap at high sparsity. As written, Figure 2 conflates component-aware grouping with manual encoder protection. That is the main empirical flaw. The stress-test note is right.\n\nAlso, Section 4.6 asserts that per-component isolation \"prevents an infeasible change of the dimensions between connected components,\" but the paper never shows how pruning an internal group in one component stays compatible with the pruned input of the next component. Shape matching is used for detection, not for synchronization. This is a genuine gap, though secondary to the confound.\n\nMinor issues: no error bars, seeds, or run counts; no code; the component-identification experiment just shows the method can count modules, which adds little. The prose is rough in places, and some related-work claims are overstated.\n\nWho should read it: people working on pruning modular or control architectures. It's a reasonable workshop-level contribution and the core idea is worth a proper test. But as is, the central claim is not established.\n\nMy recommendation: don't desk-reject. Send it to peer review, but tell the authors the comparison must be rerun with identical encoder-protection policy, error bars, and code, and they need to either prove or fix the dimension-compatibility issue. I'd want the next version before relying on it.","headline":"Plausible incremental extension of DepGraph with a confounded headline experiment: encoder protection, not smaller groups, may explain the TD-MPC gap.","tokens_in":8788,"tokens_out":2263,"would_cite":false,"duration_ms":21116,"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":"A component-aware dependency graph splits pruning into smaller, module-aligned groups, letting a TD-MPC control network reach higher sparsity before its reward collapses.","keywords":["model compression","structured pruning","dependency graph","multi-component neural architecture","component-aware pruning","TD-MPC","control policy compression"],"falsifier":"Take a two-component network and prune both components independently with this method at several sparsity levels; before each forward pass, compare the pruned output shape of the upstream component with the pruned input shape of the downstream component. Any sparsity level at which the shapes disagree while each group was pruned according to its own importance ranking would falsify the claim that per-component isolation prevents infeasible dimensional changes.","tokens_in":7882,"feed_emoji":"✂️","tokens_out":7927,"duration_ms":65915,"temperature":0.7,"pith_summary":"Structured pruning normally works by grouping weights that must be removed together, so deleting one forces consistent changes across the network. The paper's claim is that when a network is assembled from distinct components, such as an encoder, a world model, and a policy, this grouping becomes too coarse and straddles module boundaries, so any pruning damages the whole network at once. The proposed fix extends the dependency graph with component membership and inter-component interface flows, producing smaller pruning groups that stay inside one module plus separate groups for the connections between modules. Demonstrated on a TD-MPC control policy for cartpole-swingup, the approach is claimed to reach much higher sparsity before reward collapses, and the grouping also lets a user shield sensitive components like the encoder.","feed_headline":"Finer pruning groups keep control-network reward intact longer","feed_subtitle":"By isolating each module and its interfaces, a TD-MPC policy reaches far higher sparsity before its reward drops.","key_machinery":"The central object is the extended dependency criterion $D(f_i^-, f_j^+) = D_I(i,j) \\vee D_X(i,j)$, where $D_I$ is an intra-component dependency between layers in the same component, capturing either a direct data flow $f_i^- \\leftrightarrow f_j^+$ or a shared pruning scheme on a layer's input and output, and $D_X$ is an inter-component interface dependency between layers in different components that are connected through a verified data flow between the components' designated interfaces. This criterion is evaluated over all layer pairs, and the resulting graph is decomposed into per-component pruning groups plus separate groups for interface flows. It is the decomposition rule, not the importance metric (which remains $\\ell^1$ or $\\ell^2$ weight norms), that produces the paper's smaller, targeted groups.","core_discovery":"On the paper's own terms, the discovery is that component boundaries should be first-class citizens in dependency-graph pruning. Instead of treating the whole multi-component network as one chain of layers, the dependency function is split into an intra-component term and an inter-component interface term, and pruning groups are built per component with cross-component flows isolated as separate groups. In the reported experiments this turns coarse groups (for example 20 groups with an average of 4.10 operations in a branched model) into many smaller groups (33 groups with an average of 1.73 operations), and on the TD-MPC control task the component-aware version degrades gradually while the baseline loses roughly half its reward at 40% sparsity. The paper interprets this as evidence that smaller, functionally aligned groups conserve the architecture's integrity under aggressive pruning.","pith_inferences":["A direct test of the shape-consistency assumption is missing: nothing in the stated equations forces an upstream component's pruned output dimension to equal its downstream component's pruned input dimension, so a synchronization or padding rule may be needed in practice.","Because the method simultaneously changes group size and group semantics, the reported gains could come from finer granularity alone; a control experiment that randomizes group boundaries while holding group sizes fixed would separate these causes.","The component-aware grouping could be combined with stability or safety constraints to guarantee control-theoretic properties after pruning, which the paper lists as future work but does not demonstrate.","On recurrent or feedback architectures, splitting interface flows might break a loop into per-interface groups; whether this protects or disrupts temporal consistency is an open question the paper does not test."],"forward_implications":["Structured pruning becomes applicable to modular control networks without one coarse group spanning the whole model.","A TD-MPC policy can be compressed to much higher sparsity before reward degrades, which lowers the memory and compute footprint for edge deployment.","Users can assign higher importance to sensitive components, such as an encoder, so pruning pressure is redirected away from modules whose degradation would cascade downstream.","The same dependency criterion extends to branched, multi-path, and recursive architectures, so the finer grouping is not limited to the control example.","Isolating interface flows from internal flows gives practitioners finer-grained control over exactly which connections between modules are removed."],"supporting_citations":[{"why":"Supplies the baseline dependency-graph method that the paper extends and compares against as the vanilla baseline.","marker":"Fang et al., 2023"},{"why":"Defines the TD-MPC architecture whose encoder, world model, and policy form the multi-component test case.","marker":"Hansen et al., 2022"},{"why":"Provides the cartpole-swingup control environment used in the pruning experiments.","marker":"Brockman et al., 2016"}],"fun_headline_variants":["Component-aware pruning stretches sparsity without killing reward","Isolated pruning groups preserve control-network reward under sparsity","Graph-based pruning that respects module boundaries, not just layers","Smaller pruning groups from inter-component flow analysis","Boundary-aware pruning: less reward loss at high sparsity"],"cache_read_input_tokens":3200,"weakest_assumption_plain":"The load-bearing premise is that pruning internal groups and interface groups independently will never create a mismatch between a component's output dimension and its downstream component's input dimension; the paper asserts that per-component isolation prevents such infeasible changes but does not prove the synchronization mechanism.","fun_headline_variants_meta":{"raw":{"variants":["Component-aware pruning stretches sparsity without killing reward","Isolated pruning groups preserve control-network reward under sparsity","Graph-based pruning that respects module boundaries, not just layers","Smaller pruning groups from inter-component flow analysis","Boundary-aware pruning: less reward loss at high sparsity"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000361,"raw_usage":{"total_tokens":1885,"prompt_tokens":814,"completion_tokens":1071,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":430,"completion_tokens_details":{"reasoning_tokens":993}},"tokens_in":430,"tokens_out":1071,"duration_ms":8600,"temperature":1.0,"reasoning_tokens":993,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-16T12:10:45.854818+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Take a two-component network and prune both components independently with this method at several sparsity levels; before each forward pass, compare the pruned output shape of the upstream component with the pruned input shape of the downstream component. Any sparsity level at which the shapes disagree while each group was pruned according to its own importance ranking would falsify the claim that per-component isolation prevents infeasible dimensional changes.","supporting_citations":[{"cited_title":null,"cited_arxiv_id":null,"evidence_quote":"Defines the TD-MPC architecture whose encoder, world model, and policy form the multi-component test case."},{"cited_title":null,"cited_arxiv_id":null,"evidence_quote":"Provides the cartpole-swingup control environment used in the pruning experiments."}],"review_version":1}