Meta-Learned Starting Weights for Thermal Surrogates of New 3D Chip Stacks

Stacking chips vertically shortens wires but traps heat. Designers therefore need temperature predictions inside every floorplanning loop. Fast neural surrogates now exist for this. DeepOHeat-v2 predicts the temperature field of a seven-layer face-to-face chiplet stack. It runs a floorplan optimization in 292 seconds instead of 4.5 hours, with 0.55 K mean peak-temperature error. That surrogate is trained for one stack: one set of layer thicknesses, one bonding layer, one pairing of process nodes. Heterogeneous 3D design is the setting where those properties keep changing. One project pairs a 15 nm logic die with a 45 nm memory die. The next changes the bonding pitch, the thinning, or the copper density. Each such change creates a new physics problem, and today the surrogate is retrained for it.

We propose to meta-learn the surrogate's starting weights across a family of stack configurations. The training target is narrow: a few hundred steps of the surrogate's own label-free physics loss should make the network accurate on a stack it has never seen. Concretely, the inner loop adapts using only the discretized heat-equation residual, which needs no simulator labels. The outer loop, used only during meta-training, scores the adapted network on solver-computed peak temperatures. At design time a new stack therefore needs no reference simulations to bring up a trustworthy surrogate, and every later retraining event inside the optimizer becomes cheaper.

Core Claim

The claim concerns the starting point, not the architecture. Meta-learning (learning an initialization from which a few gradient steps reach a good model for any task in a distribution) can be paired with the specific adaptation procedure DeepOHeat-v2 already uses. That procedure combines a finite-volume energy loss, which discretizes heat flow cell by cell and copes with 800× conductivity contrasts, and its matrix-preconditioned optimizer. The resulting initialization should reach a fixed peak-temperature accuracy on a held-out stack in far fewer steps than three alternatives: training from scratch, fine-tuning from one stack, or fine-tuning from an average over many stacks.

Write $\theta$ for the shared starting weights and $s$ for a stack configuration drawn from a family $\mathcal{S}$. Let $U^k_s(\theta)$ be $k$ optimizer steps on the label-free finite-volume loss for $s$. Let $E_s$ be the error in peak temperature and hotspot location against a numerical solver on held-out power maps for $s$. The meta-objective is

$$\min_\theta \; \mathbb{E}_{s \sim \mathcal{S}} \left[ E_s\big(U^k_s(\theta)\big) \right].$$

The inner and outer losses are deliberately different. The inner loss is the one available at design time. The outer loss is the one designers care about.

Grounding in Prior Work

The application side is motivated by two papers. DeepOHeat trains a DeepONet, a network that maps an input function such as a power map to an output field, from physics residuals alone. It reports 0.02 to 0.16% error and 300,000× speedup over a commercial finite-element solver. DeepOHeat-v2 shows that continuous residual losses break under high material contrast and replaces them with the finite-volume loss. It also adds a trust gate that calls a numerical solver when local residuals spike, and the network then retrains incrementally. Both papers learn a surrogate for a fixed stack. Neither learns a starting point meant to transfer across stacks. We reuse DeepOHeat-v2's loss, gate and optimizer unchanged, and change only where adaptation begins and how often it is needed.

Open3DBench motivates why the stack family matters. It reports that 3D flows raise peak temperature by 10.04% over 2D. Its dual-die Nangate45_3D kit and HotSpot 7.0 thermal model also give a realistic source of power maps. Analytical heterogeneous die-to-die placement shows why heterogeneity changes the physics: footprints and densities scale with the tier a block lands on. Different node pairings therefore yield different power-density statistics, not just relabeled ones.

The method side comes from model-agnostic meta-learning, in which the initialization is updated by differentiating through inner gradient steps. It traces back to Optimization as a Model for Few-Shot Learning. The survey of adaptive physics-informed networks reports that meta-learned priors cut the cost of solving parametric PDE families. That supports feasibility, but it does not address high-contrast multilayer stacks or the gap between a residual loss and a peak-temperature target. Make One-Shot Video Object Segmentation Efficient Again argues that ordinarily pretrained weights must first "unlearn" source features before adapting. That is our hypothesis for why single-stack fine-tuning will be slow.

One result constrains the design. The research file notes that meta-initializations can fall below random initialization when the target lies outside the training support. We therefore treat extrapolation to unseen stack types as a separate, pre-registered test rather than folding it into the main result. Meta-Learning Universal Priors Using Non-Injective Change of Variables shows that a single initialization can collapse toward an unhelpful average when tasks are multimodal. Thermally, stacks with and without dense copper through-vias may form such distinct modes. We hold that paper's method in reserve as a fix if a single starting point fails.

Placement-side transfer work, such as ChiPFormer with its offline pretraining across 2D netlists, learns policies rather than physics surrogates. It does not optimize for few-step adaptation.

Research Program

We first build a stack family. We parameterize the seven-layer face-to-face chiplet of DeepOHeat-v2 by four things: layer thicknesses, bonding-layer effective conductivity (set by copper fill, within the 0.5 to 400 W/m·K range), through-via density maps, and a node pairing that rescales power density per tier. We sample a few hundred stacks for meta-training. We hold out a set drawn from the same ranges, and a second set that extrapolates in bonding conductivity and layer count. Power maps come from random fields, as in DeepOHeat-v2's 10,000 maps, and from Open3DBench implementations of Ariane and BlackParrot.

Second, we meta-train. Backpropagating through hundreds of preconditioned steps on a 2.07-million-cell grid will not fit in memory. We therefore compare a first-order meta-gradient against Reptile-style averaging of adapted weights. We train the inner loop at small $k$ and test at larger $k$.

Third, we plug the meta-initialization into DeepOHeat-v2's full floorplanning loop. There we measure whether retraining after each trust-gate trigger converges faster and whether fewer solver calls are needed.

Baselines

The naive reference is training a fresh DeepOHeat-v2 surrogate from random weights on each held-out stack. It uses the same finite-volume loss, optimizer and power-map budget. We count its full cost, because the pretraining time for a new stack is the cost we aim to remove.

The strongest existing method is DeepOHeat-v2 itself, pretrained on one source stack and adapted to the target with its own incremental retraining. Its reported in-distribution figures are 0.55 K mean peak-temperature error, 292 seconds for the optimization loop, 91.7% of errors above 1 K caught by the trust gate, and a final design within 0.11 K of the numerical optimum. We found no reported result on Lacuna for any thermal surrogate transferred to a stack geometry different from its training stack. Our transfer comparison is therefore new rather than a reproduction. Beating DeepOHeat-v2 means matching its 0.55 K accuracy on held-out stacks with at least five times fewer adaptation steps, at equal wall-clock budget and identical tuning sweeps, while keeping trust-gate recall at or above 91.7%.

The ablation that isolates the key ingredient is multi-stack average pretraining. It uses the same stack family, the same total compute and the same network, but minimizes average loss rather than post-adaptation loss. A second ablation meta-trains with the continuous PDE residual instead of the finite-volume loss as the inner objective. It tests whether matching the initialization to the actual adaptation procedure matters. A third uses the outer loss equal to the inner residual, removing the solver-labelled peak-temperature target.

Why not just…?

Why not just pretrain on many stacks and fine-tune? This is the most serious threat. With enough stack diversity, average pretraining may already sit near every task's solution, and meta-learning would add cost (the file notes 1.5 to 2× longer meta-training in derivative-free meta-learning) for nothing. The matched-compute ablation above settles it directly. If average pretraining reaches the 1 K accuracy threshold within 20% of the meta-initialization's step count, we will report that average pretraining suffices and drop the meta-learning claim.

Why not just feed the stack description into the operator so no adaptation is needed? A DeepONet already accepts input functions, so the conductivity field could become another branch input, and a single amortized model could be zero-shot. This is a real alternative, and we will build it with the same parameter count. Our expectation, which is untested, is that it works inside the training ranges but degrades under extrapolation, where it has no mechanism to correct itself. The fair resolution is also the likely best system: meta-learn the starting weights of the conditioned operator. Then the label-free inner loop corrects whatever conditioning misses. We report the conditioned model alone, the meta-initialization alone, and both together.

Why not just use a compact thermal model or call the solver? HotSpot-style compact models are fast and are what Open3DBench uses. DeepOHeat-v2, however, shows that calling an accurate solver at every step costs 4.5 hours, while coarse models lose hotspot detail under copper/dielectric contrast. We include HotSpot 7.0 as a speed–accuracy reference point on the Open3DBench maps, so readers can see where the surrogate is and is not worth having.

Decisive Checks

The primary metric is adaptation steps and wall-clock time to reach 1 K peak-temperature error on held-out in-range stacks, plotted as error against step for every baseline. Secondary metrics are final error after a fixed budget, trust-gate recall, solver calls per floorplan optimization, and gap to the numerical optimum in DeepOHeat-v2's floorplanning task. We also run this on Open3DBench Ariane and BlackParrot power maps, with HotSpot as a second reference.

The idea fails if any of three things happens. First, matched-compute average pretraining comes within 20% of the meta-initialization's step count. Second, the meta-initialization does worse than training from scratch on the extrapolation set. Third, solver calls inside the optimization loop do not fall. Any of these is a useful negative result for the broader proposal to meta-learn physics surrogates in 3D design.