Why does averaging the weights of two independently initialized runs produce a broken model?

## The claim being tested Averaging parameters assumes something strong and usually unstated: that the straight line between the points you are averaging stays in a low-loss region, so the midpoint is a good model. Along one training trajectory late in a run this tends to hold. Between two independent runs it does not, and the failure is dramatic rather than gradual - the average is typically no better than a random network. ## Permutation symmetry Take any hidden layer and swap two units: exchange their incoming weight rows, their biases and their outgoing weight columns. The network computes **exactly the same function**. A layer of `n` units therefore admits `n!` weight vectors that are functionally identical, and a deep network multiplies these across layers - an astronomically large set of equivalent parameterizations of the same model. Two independent runs, with different initializations and different data orders, land in arbitrary members of these equivalence classes. Even if they learned *the same features*, the run-A vector might place an edge detector at index 7 and the run-B vector at index 214. Coordinate-wise averaging adds the run-A edge detector to whatever run B happened to put at index 7 - a completely unrelated feature - and halves both. Every unit in the averaged network becomes a meaningless blend, and the downstream layers, whose weights were also blended, are reading from features that no longer exist. Symmetry is not the whole story - scale symmetries between layers, and the simple fact that the two runs may have found genuinely different solutions, contribute too - but permutation is the cleanest way to see why coordinate-wise averaging has no reason to work. ## The barrier, and how to measure it The operational version of this is **linear mode connectivity**. Take weight vectors `w_A` and `w_B` and evaluate the training loss at `w(a) = (1 - a) * w_A + a * w_B` for `a` in `0, 0.1, ..., 1.0`. If the curve stays flat or dips, the two points are linearly connected and averaging is safe. If it spikes in the middle, they are in different basins and the average is garbage. This costs a handful of evaluation passes and is worth running once before you build any averaging procedure on an assumption you have not checked. Note that you must recompute any normalization running statistics at each interpolation point, or you will measure a barrier that is really a buffer mismatch. Two important refinements: - **A shared prefix buys connectivity.** If both runs share the first part of training - the same initialization and the same early steps - and only diverge afterwards, the two endpoints often *are* linearly connected, and averaging works. This is the mechanism behind averaging several fine-tunes of one shared pretrained starting point: because they start from a common point and move relatively little, they usually stay in one region, and the average of them can beat any individual fine-tune. The rule is not 'one run' but 'one basin', and a shared trajectory is the practical way to guarantee it. - **Alignment can remove the barrier.** Research on permuting one network's units to match the other's shows that after such an alignment the barrier between two independently trained networks can be greatly reduced. That is a real result, but it requires solving the matching problem explicitly; it is not what happens if you simply add two checkpoints together. ## Contrast with prediction averaging The reason this surprises people is that averaging the **outputs** of two independent runs works fine, and works better the more independent the runs are - diversity is the whole point of an ensemble. Parameter averaging has the opposite requirement: it needs the models to be nearly the same model, differing only by the noise you are trying to cancel. When someone proposes 'averaging the models', the first clarifying question is which of the two operations they mean, because their preconditions are opposites. ## Practical rules 1. Average checkpoints from a single run, harvested after the trajectory has settled. 2. Or average fine-tunes that share one initialization and one early trajectory - and verify with an interpolation check. 3. Never average across different seeds, different architectures, or different layer widths. 4. Recompute normalization statistics after averaging, so a genuine barrier is not confused with a buffer mismatch. 5. If you want the benefit of independent runs, ensemble their predictions instead, and pay the inference cost.