Interpretable "concept bottleneck" models make a prediction in two steps. A network first predicts human-named attributes of the input, such as "red wing" or "joint space narrowing", and a simple classifier then predicts the label from those attributes alone. Because human concept lists are incomplete, these models lose accuracy. The usual fix is a sidechannel: an unnamed extra pathway that carries whatever the concepts miss. The trouble is that a freshly initialized sidechannel tends to take over. It learns the easy signal first, the concepts become decorative, and correcting a concept at test time no longer changes the prediction. We propose controlling this with the scale at which the sidechannel is initialized, not with a loss penalty. The sidechannel is written as a product of two small matrices and starts close to zero. Learning theory for this "small factored initialization" predicts that each direction grows at a rate proportional to the error that is still unexplained, so it stays dormant until the concept pathway has done what it can. It then switches on one direction at a time, in order of how much residual error each direction explains.
The practical consequence is what makes the idea worth testing. If the mechanism holds, a single training run sweeps through a range of models. Early checkpoints are pure concept models, later checkpoints add one sidechannel direction at a time, and an analyst can choose a point on the accuracy–interpretability curve after training instead of retraining once per penalty strength. The few directions that do switch on are also natural candidates for being named afterwards.
Core Claim
Our hypothesis is that, in a jointly trained concept-plus-sidechannel model, three things follow from initializing a factored sidechannel at small scale $\alpha$. The concepts are learned first. Sidechannel capacity is then recruited in rank-ordered steps. The checkpoints along one run trace an accuracy-versus-concept-reliance curve that matches or dominates the curve obtained by tuning an explicit independence penalty, at a fraction of the training cost. We are not proposing to zero-initialize a single linear head. That design fails for a simple reason: the gradient of a zero linear head equals the output error multiplied by a nonzero sidechannel feature. The head is therefore pulled away from zero on the first step, and setting it to zero only postpones the takeover by a few iterations. The slow start requires a multiplicative parameterization, which is why the factorization is the key ingredient.
Concretely, let the label logits be $y = W_c\,\hat c + U V^\top z$. Here $\hat c$ are the predicted concepts, $W_c$ is the transparent concept-to-label layer, $z$ is the sidechannel feature from the backbone, and $U, V$ are factor matrices initialized at scale $\alpha \ll 1$. In the linearized picture, each singular value $s_i$ of $UV^\top$ obeys
$$\dot s_i \approx 2\, s_i\, \rho_i(t),$$
where $\rho_i(t)$ is the correlation between the current residual error and the $i$-th sidechannel feature direction. The relation follows from gradient flow on a two-factor product, the same mechanism behind the greedy low-rank learning reported for ZerO Initialization. Growth is exponential with escape time roughly $\log(1/\alpha)/\rho_i$. Directions whose signal the concepts already capture have small $\rho_i$ and stay near zero. The quantity $\alpha$ is thus a single knob that sets how long the model runs as a pure concept model.
Relation to Prior Work
Three papers motivate the gap. Quantifying the Accuracy-Interpretability Trade-Off in Concept-Based Sidechannel Models documents the "accuracy trap": unregularized sidechannel models route prediction through the sidechannel. To counter it, the paper introduces the Sidechannel Independence Score (SIS) and an SIS penalty that traces a Pareto front. It leaves initialization unexamined, and that is the slot we fill. Concept Bottleneck Models establishes the accuracy cost of pure bottlenecks on CUB (19.9% error for the jointly trained model against 17.5% for the black box). It also establishes the payoff we want to preserve, which is test-time intervention. The Surprising Simplicity of the Early-Time Learning Dynamics of Neural Networks argues that networks behave like linear models early in training. That observation explains why whichever pathway is easiest to fit linearly at initialization wins.
Two lines supply the method. The first is identity-biased initialization. Identity Matters in Deep Learning, the zero-scale residual trick in Bag of Tricks, and the global-convergence analysis of deep linear ResNets all start a residual branch near zero so that the base path dominates early. These works use that ordering for optimization stability. We repurpose it for interpretability, and the "base path" becomes the concept pathway. The second is ZerO, which shows that deterministic near-identity starts produce lower-rank, sparser solutions. We use that rank-ordering as the source of a curve one can traverse along a single run.
Two papers constrain the design. A Unifying Network Architecture for Semi-Structured Deep Distributional Learning stops a deep branch from stealing variance from an additive model by projecting the deep features onto the complement of the interpretable features at every step. Our mechanism is a soft, dynamic analogue: residual-driven growth leaves concept-explained directions untouched without any explicit projection. Because that projection is the closest exact competitor, we include it as a baseline. Layer-Wise Interpretation of Deep Neural Networks Using Identity Initialization is the only prior work that ties identity initialization directly to interpretability. It does so for spatial heatmaps in MLPs and pays a generalization gap. We use initialization to preserve semantic concept reliance, not a pixel coordinate frame, and we leave the backbone's initialization standard, so that paper's generalization penalty should not transfer. Incremental Residual Concept Bottleneck Models and Hybrid Concept Bottleneck Models name learned residual vectors after training by matching them against a concept bank or a text decoder. A low-rank, rank-ordered sidechannel should be easier input for that kind of naming, but naming is downstream of our claim, not part of it.
Research Program
We first build the model on the concept-sidechannel template of Debot and Marra. A shared backbone feeds a concept head and a sidechannel encoder. The label head is the transparent concept layer plus the factored sidechannel $UV^\top$ with rank cap $r$ (for example, 32). We train the whole model jointly from a standard backbone initialization, sweeping $\alpha$ over several orders of magnitude.
The analysis measures, along each run, the singular values of $UV^\top$, concept accuracy, task accuracy, SIS, and intervention responsiveness. Responsiveness is the gain in task accuracy when predicted concepts are replaced by ground truth. These measurements test the three predictions: dormancy, ordered recruitment, and an escape time that scales as $\log(1/\alpha)$. We will also check where the linear picture breaks down. The theory is linear and the backbone is not, which is the open "linear versus non-linear" gap noted in the identity-initialization literature. A finding that the backbone learns to inflate $\rho_i$ for sidechannel directions, and so defeats the slow start, would be an informative negative result.
Finally, we compare the curve traced by the checkpoints of one small-$\alpha$ run against the frontier obtained from many SIS-penalty runs. As a cheaper variant, we also truncate a trained sidechannel to its top-$k$ singular directions after training.
Baselines
The naive reference points come from the CBM paper on CUB: the black-box model (17.5% error) and the jointly trained pure concept model (19.9%). The latter is what we get at the limit where the sidechannel never wakes up. The black box sets the accuracy ceiling and the joint model sets the interpretability anchor. We also run the unregularized sidechannel model with standard initialization. It should show the accuracy trap, and it is the configuration our method must improve on in concept reliance.
The strongest existing competitor is SIS regularization from Debot and Marra. It is designed for exactly this trade-off and is evaluated on CelebA and MNIST-Addition. No reported numeric result for SIS was found on Lacuna, so we will reproduce it. For a fair comparison, both methods get the same backbone, data, and epochs. SIS receives a sweep of penalty strengths whose total compute equals that sweep, and our method receives the same number of $\alpha$ values. We also report the single-run checkpoint curve with its true, much lower, cost. Our method counts as beating SIS if its curve dominates or matches the SIS front, meaning equal or higher task accuracy at equal SIS and intervention responsiveness, at no more total compute. It also counts as a win if a single run recovers the front within one standard deviation of the seeds.
The semi-structured orthogonalization cell is the exact-projection competitor. We will adapt it by projecting $z$ onto the complement of the span of $\hat c$ within each minibatch.
The key ablation isolates the factorization. It keeps the same rank cap $r$ but uses either standard initialization or a zero-initialized single linear head. If those variants match the small factored start, the mechanism is just capacity limiting and our claim fails.
Why not just…?
Why not just train sequentially, concepts first and then a residual sidechannel? Fitting the concept model, freezing it, and fitting a sidechannel to the leftover error enforces "concepts first" by construction. This is the most serious threat. It differs from our method in two testable ways. It freezes the concept encoder, so the concepts cannot co-adapt as the residual is learned. It also yields an unordered residual unless a rank constraint is added. We run it, both with and without the rank cap $r$, under the same compute. If the capped sequential variant matches our frontier, we will report that the contribution reduces to a one-run curve and a cheaper schedule, not a better trade-off.
Why not just shrink the sidechannel to a few dimensions or lower its learning rate? A tiny sidechannel or a slow one limits takeover, but at a fixed operating point chosen in advance. A small standard-initialized sidechannel still trains in parallel with the concepts from the first step, which is the condition the early-time-dynamics result says produces the trap. The rank-matched standard-initialization ablation and a lower-learning-rate variant at matched rank test this directly.
Why not just use SIS regularization or orthogonal projection? Both work, and both are run as baselines. Their costs are a separate training run per penalty value, or a per-step projection. Our claim is only that initialization reaches the same front more cheaply. If either dominates our curve, the claim fails.
Why not just apply post-hoc attribution or a CLIP linear probe? Neither supports concept intervention. HybridCBM's comparison already shows that a CLIP linear probe (70.1% on CIFAR-100) beats an interpretable hybrid (68.38%) while remaining unnamed. We treat that gap as the target, not as a reason to abandon bottlenecks.
Proposed Experiments
MNIST-Addition, used by Debot and Marra, provides controlled ground truth on which concepts suffice. There, the sidechannel should remain at rank near zero, and any growth counts as leakage. CUB, with its 112 attributes, and CelebA, with its 40 attributes and incomplete-concept settings, test the realistic regime. In both we report task error against the 17.5% and 19.9% CUB anchors and against CEM's reported 5% CelebA gain over the black box. We also report concept accuracy, SIS, and intervention responsiveness.
CUB+Places tests the side effect that matters most. CBMs reach roughly 48–49% error under background shift against 62.7% for the black box. A sidechannel that wakes up late should absorb less background shortcut, and we measure where on our curve that robustness is lost.
The decisive checks are four, with all differences assessed over five seeds. First, the escape time of the leading sidechannel direction should scale linearly in $\log(1/\alpha)$. Second, the checkpoint curve from one run should match the SIS front. Third, the rank-matched standard-initialization ablation should fall into the accuracy trap while the factored small start does not. Fourth, capped sequential training should not dominate.
References
- ZerO Initialization: Initializing Residual Networks with only Zeros and Ones
- Quantifying the Accuracy-Interpretability Trade-Off in Concept-Based Sidechannel Models
- Concept Bottleneck Models
- The Surprising Simplicity of the Early-Time Learning Dynamics of Neural Networks
- Identity Matters in Deep Learning
- Bag of Tricks for Image Classification with Convolutional Neural Networks
- On the Global Convergence of Training Deep Linear ResNets
- A Unifying Network Architecture for Semi-Structured Deep Distributional Learning
- Layer-Wise Interpretation of Deep Neural Networks using Identity Initialization
- Incremental Residual Concept Bottleneck Models
- Hybrid Concept Bottleneck Models