E3SM-Project/aigs-hack-sep26-latents

Emulator latents for the E3SM AI group hackathon, 25 September 2026

What two E3SMv3 emulators hold inside, recorded step by step, with the physical fields beside them, so you can find features, follow them through the network and through time, and set an intervention against its control.

Read every result with this in mind. These checkpoints show how the model represents forcing, not what forcing does to the climate. Neither checkpoint is fit for forcing or scenario experiments. How each of them represents forcing, and where, is one of the hackathon's questions.

The models

Component	Checkpoint	Network	Grid, step
Atmosphere	E05-FT.aug26.atm.A3_B16_C1_L0_O5_W0_X0.S01	noise-conditioned SFNO: encoder + 8 blocks, 384 channels	1° Gaussian (180×360), 6 h, SST prescribed
Ocean	E11-FT.aug26.ocn.A0_B16_C0_L0_O5_W0_X0.S01	Samudra U-Net (280/380/480/520 channels)	1° (180×360), 5 days, surface fluxes prescribed

Both were trained on the E3SMv3 historical run (v3.LR.historical_0101). The checkpoints and a small kit to rerun every experiment here are in the companion model repo, E3SM-Project/aigs-hack-sep26-models.

The runs

Every atmosphere run starts from the same state (2015-01-03 12:00, the emulator's own century run) with the same seed. The atmosphere is stochastic, so the seed is what makes two runs comparable node for node.

Folder	What changed	Times	Layers
atm-E05S01-ctrl	nothing: the control; holds the bases	20 (5 days)	0–8
atm-E05S01-ctrl-30d	the control, 30 days, for Hovmöllers and tracking; holds its own bases	120	0, 2, 4, 6, 8 (stored as 0–4)
atm-E05S01-ctrl-seed1 … -seed4	the control with seeds 1–4: what the model's own noise does	20	0–8
atm-E05S01-co2x1.25, co2x0.8	global-mean CO₂ scaled; SST fixed	20	0–8
atm-E05S01-sst+4K	SST +4 K everywhere	20	0–8
atm-E05S01-aerfrz	aerosol diagnostics (aerindexall, colccn.3) frozen at 1965	20	0–8
steer-L0f142-plus3, -minus3	SAE feature 142 of layer 0 pushed by ±3 at every node and step	20	0–8
steer-L8f242-plus3, -minus3	SAE feature 242 of layer 8 pushed by ±3	20	0–8
steer-ctrl-plusCO2dir, -plus2CO2dir	the control, with CO₂ ×1.25's mean layer-0 shift added once or twice	20	0–8
steer-co2x1.25-minusCO2dir	CO₂ ×1.25, with that shift subtracted at layer 0	20	0–8
steer-ctrl-plusCO2dirL4, -L8; steer-co2x1.25-minusCO2dirL4, -L8	the same at layers 4 and 8, with those layers' own shifts	20	0–8
skip-co2x1.25-skipsees-ctrl	CO₂ ×1.25, except in the copy of the inputs the SFNO's big skip hands the decoder	20	0–8
skip-ctrl-skipsees-co2x1.25	the control, except the big skip sees CO₂ ×1.25	20	0–8
ocn-E11S01-ctrl	the ocean from 2040-01-01	20 (100 days)	2
ocn-E11S01-flusfrz	the same, with the upward-longwave input (FLUS) frozen at its 1965 values	20	2

Atmosphere layers: 0 is the encoder output (the input to block 1), 1–8 the outputs of blocks 1–8. Ocean layers are the two full-resolution levels of the U-Net: 0 the first encoder block's output, 1 the last decoder block's.

Layout

One folder per run, in the xaig latent-archive layout:

<run>/
  manifest.json      times, layers, and provenance: checkpoint, config, initial condition, seed, intervention
  grid.npz           lat, lon per node; grid_shape (180, 360); mask for the ocean
  step_NN.npy        (times, 64800 nodes, channels), float16, one file per layer (~1 GB for 20 times)
  reference.nc       physical fields at every time: the model's outputs, plus its inputs as the network saw them
  bases/             (controls only) pca_LNN.npz and sae_LNN.npz, one per layer

Fields in reference.nc include precipitation, 2-m temperature, TOA and surface radiation, fluxes, winds and temperature at several model levels, liquid water path, and the inputs SOLIN, global_mean_co2, aerindexall, colccn.3, OCNFRAC, ICEFRAC, LANDFRAC, PHIS (atmosphere) or the surface fluxes (ocean). Latents are labelled with the time of the state each step starts from; the fields hold one more time, the last step's output. Diagnostic outputs (precipitation, fluxes) are empty at the first time.

Bases

Fitted on each control, every node and every time, area-weighted: PCA (32 components) and a TopK sparse autoencoder (1,024 features, k = 32) per layer for atm-E05S01-ctrl; SAEs for atm-E05S01-ctrl-30d and ocn-E11S01-ctrl. Their quality is measured in-sample. A basis records the network and layer it was fitted on and is refused anywhere else; it serves every run of the same network.

Noise

The atmosphere draws noise at every step. All runs share seed 0, so a difference between two of them is the intervention's doing, but even so the runs drift apart. The seed runs measure how far a new noise draw alone moves each layer: read a difference against them, with xaig daig latent diff CONTROL RUN --growth --noise atm-E05S01-ctrl-seed1.

Use

With xaig[hf] (0.2 or later), a run opens in place and only the files you touch are downloaded — each layer is one file of about 1 GB:

from xaig.daig.latent import open_source, rank_by_field, load_basis

source = open_source("hf://datasets/E3SM-Project/aigs-hack-sep26-latents/atm-E05S01-ctrl")
sae = load_basis(source.file("bases/sae_L08.npz"))
ranking = rank_by_field(source, time=4, layer=8, field="surface_precipitation_rate", basis=sae)

The hackathon's no-code notebook opens these runs the same way.

Reproduce a run

Every atmosphere run here can be recorded again, bit for bit, on any machine with a GPU (about 4 GB of GPU memory; 20 steps take a few minutes). The checkpoint, the initial condition, two months of forcing, a config per intervention, the exporter and the steering vectors are in the model repo; the SAE bases are here.

$ pip install "fme @ git+https://github.com/E3SM-Project/ace@e3sm/exps/hist-v2026.8.0" "xaig[hf]>=0.3"
$ hf download E3SM-Project/aigs-hack-sep26-models --local-dir aigs-models && cd aigs-models
$ hf download E3SM-Project/aigs-hack-sep26-latents --repo-type dataset \
    --include "atm-E05S01-ctrl/bases/*" --local-dir latents
$ python kit/export_fme_latents.py kit/configs/atm-ctrl.yaml --out runs/atm-E05S01-ctrl --steps 20

Every run is that last command with its own config and options:

Run	Config	Options, after --steps 20
atm-E05S01-ctrl	atm-ctrl.yaml
atm-E05S01-ctrl-30d	atm-ctrl.yaml	--steps 120 --layers 0,2,4,6,8 (instead of --steps 20)
atm-E05S01-ctrl-seedN	atm-ctrl.yaml	--seed N
atm-E05S01-co2x1.25, -co2x0.8	atm-co2x1.25.yaml, atm-co2x0.8.yaml
atm-E05S01-sst+4K	atm-p4K.yaml
atm-E05S01-aerfrz	atm-aerofrz.yaml
steer-L0f142-plus3, -minus3	atm-ctrl.yaml	--steer 0:latents/atm-E05S01-ctrl/bases/sae_L00.npz:142:3 (:-3)
steer-L8f242-plus3, -minus3	atm-ctrl.yaml	--steer 8:latents/atm-E05S01-ctrl/bases/sae_L08.npz:242:3 (:-3)
steer-ctrl-plusCO2dir, -plus2CO2dir	atm-ctrl.yaml	--steer-vector 0:kit/vectors/co2x1.25_L0_meandiff.npy:1 (:2)
steer-co2x1.25-minusCO2dir	atm-co2x1.25.yaml	--steer-vector 0:kit/vectors/co2x1.25_L0_meandiff.npy:-1
steer-ctrl-plusCO2dirL4, -L8	atm-ctrl.yaml	--steer-vector 4:kit/vectors/co2x1.25_L4_meandiff.npy:1 (layer and file 8 for -L8)
steer-co2x1.25-minusCO2dirL4, -L8	atm-co2x1.25.yaml	--steer-vector 4:kit/vectors/co2x1.25_L4_meandiff.npy:-1 (likewise)
skip-co2x1.25-skipsees-ctrl	atm-co2x1.25.yaml	--skip-rescale global_mean_co2:0.8
skip-ctrl-skipsees-co2x1.25	atm-ctrl.yaml	--skip-rescale global_mean_co2:1.25

Each archive's manifest.json records what was done under experiment: the config, the seed, the intervention and the steering, so a run can always be traced back to its row here. The two ocean runs need inputs the kit does not carry.

How steering works

The exporter hooks the network and, besides reading a layer, can write one: it adds a fixed direction to that layer's output at every node, at every step (or only the steps --steer-window FIRST:LAST names), and lets the model run on from there. Layer numbers are the archives' own: 0 is the encoder output, as the first block receives it; L the output of block L.

• --steer L:BASIS.npz:FEATURE:ALPHA adds ALPHA times one feature's direction from a basis file. For an SAE the direction is the feature's decoder direction, scaled so that ALPHA is in the feature's own activation units: +3 is a firm push, more than a typical feature reads where it fires. For a PCA it is the component, in the layer's units. Any basis fitted on that layer of this network will do, including one you fit yourself.
• --steer-vector L:VECTOR.npy:ALPHA adds ALPHA times any saved vector of the layer's width (384).
• --steer-channel L:CHANNEL:AMOUNT adds a constant to one channel.
• --skip-rescale NAME:FACTOR is not steering a layer but splitting an input: the SFNO hands a copy of its raw inputs straight to the decoder, past every block (its big skip). This scales one input, in physical units, in that copy only, so the blocks and the skip can be shown different worlds.

Keep the seed at 0 for anything set against the control: with the same seed and ALPHA = 0, a steered run is the control, bit for bit.

The three vectors in kit/vectors/ are the difference CO₂ ×1.25 makes to a layer at the first time, averaged over the globe by area — one number per channel. They can be recomputed from this dataset, and the same recipe makes a vector from any pair of runs:

import numpy as np
from xaig.daig.latent import open_source

url = "hf://datasets/E3SM-Project/aigs-hack-sep26-latents/"
control, co2 = open_source(url + "atm-E05S01-ctrl"), open_source(url + "atm-E05S01-co2x1.25")
w = control.grid().weights()
w = w / w.sum()
shift = (w @ (co2.load(0, 4) - control.load(0, 4))).astype("float32")  # layer 4, first time
np.save("co2x1.25_L4_meandiff.npy", shift)  # identical to kit/vectors/

Making your own steering vector

A steering vector is one number per channel of a layer (384 for the atmosphere), saved with np.save; any such array can be passed as --steer-vector L:file.npy:ALPHA. Four ways to make one:

1. The difference between two runs, as above: any pair (atm-E05S01-sst+4K and the control, say), any layer, any time or several averaged, over the globe or a region (zero the weights outside it).

2. A contrast within one run: the mean latent where something is true minus where it is not. Heavy rain at layer 8, for instance:

   import numpy as np
   from xaig.daig.latent import open_source
   
   run = open_source("hf://datasets/E3SM-Project/aigs-hack-sep26-latents/atm-E05S01-ctrl")
   w = run.grid().weights()
   t, layer = 4, 8
   x = run.load(t, layer).astype(float)
   rain = run.field("surface_precipitation_rate", t)
   wet = np.isfinite(rain) & (rain > np.nanpercentile(rain, 90))
   dry = np.isfinite(rain) & ~wet
   v = w[wet] @ x[wet] / w[wet].sum() - w[dry] @ x[dry] / w[dry].sum()
   np.save("rain_L08.npy", v.astype("float32"))  # --steer-vector 8:rain_L08.npy:0.5
   

   Land against ocean (LANDFRAC), day against night (SOLIN), or a region against the rest work the same way.

3. A basis direction: load_basis(...).directions()[f], one SAE feature or PCA component. --steer does this for you, with ALPHA in the feature's own units.

4. A linear probe: the least-squares weights that best predict a field from the layer's channels.

Before steering with it, see what it is:

from xaig.daig.latent import load_basis

v = np.load("rain_L08.npy").astype(float)
wn = w / w.sum()
spread = np.sqrt(wn @ ((x - wn @ x) ** 2).sum(1))  # how far a typical node sits from the layer's mean
print(np.linalg.norm(v) / spread)  # how big a push ALPHA = 1 is
print(np.argsort(-abs(v))[:10])  # the channels it leans on most
D = load_basis(run.file(f"bases/sae_L{layer:02d}.npz")).directions()
cos = D @ v / np.linalg.norm(D, axis=1) / np.linalg.norm(v)
print(np.argsort(-abs(cos))[:5])  # the SAE features it lines up with

Two cautions. A steering vector adds the same push at every node, so it can stand in only for the part of a change that is the same everywhere; a change with a pattern on the map is more than one vector can say. And size ALPHA against the layer's spread: start small, and always set the run against the control with the same seed.

Provenance and citation

Recorded with kit/export_fme_latents.py from the model repo (forward hooks on fme's SFNO and Samudra), with fme from the E3SM-Project/ace branch e3sm/exps/hist-v2026.8.0. The analysis follows Tempest, Beylich & Craig (2026, arXiv:2604.20467) and MacMillan & Ouellette (2025, arXiv:2512.24440); cite them if you use it.