🔭 astrophysics

TUNeS: Neural Emulation of Large-Scale Structure Across Redshifts

This paper introduces TUNeS, a neural network framework that rapidly and accurately emulates the nonlinear evolution of large-scale structure across redshifts by combining particle-based inference with grid-based refinement, achieving high-fidelity statistical reproduction of N-body simulations in seconds on a single GPU.

Original authors: Yuqi Kang, Hu Bin, Dongxing Li, Jan Hamann

Published 2026-03-20

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Yuqi Kang, Hu Bin, Dongxing Li, Jan Hamann

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine the universe as a giant, cosmic ball of dough. When the universe began, this dough was smooth and uniform. But over billions of years, gravity acted like a giant hand kneading it, pulling some parts together into clumps (stars and galaxies) and stretching others out into empty voids.

For decades, scientists have tried to predict exactly how this dough gets kneaded using massive supercomputer simulations called N-body simulations. Think of these simulations as trying to track every single grain of sand in a beach to see how the waves move them. It's incredibly accurate, but it takes so much computing power and time that it's like trying to bake a cake the size of a mountain just to see if the frosting looks right.

Enter TUNeS: The Cosmic "Fast-Forward" Button

This paper introduces a new tool called TUNeS (Temporal UNet emulator for Structure formation). Think of TUNeS as a highly trained AI chef who has watched thousands of hours of dough-kneading videos. Instead of calculating the physics of every single grain of sand from scratch, TUNeS looks at the dough at one moment and instantly predicts what it will look like later.

Here is how it works, broken down into simple steps:

1. The Two-Stage Strategy: The Rough Sketch and the Fine Art

TUNeS doesn't try to do everything at once. It uses a clever two-step process, like an artist sketching a landscape before painting the details.

Stage 1: The "Big Picture" Sketch (Particle Inference)
Imagine you have a bag of marbles (particles) representing the universe. TUNeS first looks at where the marbles are and where they are moving. It quickly guesses the general direction they will drift. This is like drawing a rough outline of a mountain range. It captures the big, easy-to-see movements but misses the tiny rocks and cracks.
- The Magic: It does this using a neural network that learns the "rules of the road" for how gravity moves things on a large scale.
Stage 2: The "Fine Detail" Painting (Density Refinement)
Once the rough sketch is done, TUNeS turns those marbles into a digital image (a density grid). Now, it uses a second, more detailed AI (called a U-Net) to paint in the tiny, messy details. This is where the complex clumps, the sharp edges of galaxies, and the intricate web of cosmic structures are filled in.
- The Magic: This stage acts like a high-resolution filter that takes a blurry photo and makes it crystal clear, adding the "non-linear" chaos that happens when matter gets very crowded.

2. The "Window" Trick: Solving the Puzzle Piece by Piece

One of the biggest problems with simulating the whole universe at once is that it's too big to fit in a computer's memory. It's like trying to hold a giant jigsaw puzzle in your hands all at once.

TUNeS solves this by using a windowing strategy. Imagine looking at the universe through a small square window. TUNeS looks at one window, figures out the details, then slides the window over to the next spot, and so on. Finally, it stitches all these windows together like a quilt.

Why it's great: You can simulate a universe as big as you want without needing a supercomputer the size of a city. You just need a standard gaming graphics card (like an NVIDIA RTX 4090).

3. The Results: Fast and Accurate

The authors tested TUNeS by training it on just eight simulations (a tiny amount for this field). They then asked it to predict the universe at different times (redshifts).

Speed: It takes about 25 seconds on a single graphics card to simulate the evolution of the entire universe from a starting point to a target time. A traditional supercomputer simulation might take days or weeks for the same job.
Accuracy: The results are shockingly good.
- The "Gaussian" Test: It gets the general shape and distribution of matter right (like getting the overall flavor of a soup right).
- The "Non-Gaussian" Test: It also gets the weird, clumpy, complex details right (like getting the specific crunch of the croutons right).
- The "Topological" Test: It even gets the shape of the cosmic web (the holes, the tunnels, and the bridges) correct, which is very hard to do.

Why Should We Care?

In the past, if scientists wanted to test a new theory about the universe, they had to wait weeks for a supercomputer to run a simulation. Now, with TUNeS, they can run thousands of simulations in the time it takes to brew a cup of coffee.

This is a game-changer for:

Future Surveys: Upcoming telescopes will take pictures of billions of galaxies. We need to compare those pictures against millions of simulated universes to understand what we are seeing. TUNeS makes this possible.
Dark Energy & Dark Matter: By running these simulations quickly, scientists can test different theories about the invisible stuff that makes up most of the universe.

In a Nutshell:
TUNeS is a smart, fast, and flexible AI that learns to "fast-forward" the history of the universe. It skips the heavy math of calculating every particle's movement and instead uses a two-step "sketch-and-paint" method to recreate the cosmic web with incredible speed and surprising accuracy. It turns a task that used to require a supercomputer into something you can do on a powerful laptop.

1. Problem Statement

Cosmological surveys are generating high-precision data over unprecedented volumes and redshift ranges. Exploiting this data requires large ensembles of numerical simulations to characterize systematic uncertainties and estimate covariance matrices. However, standard N-body simulations, while accurate for modeling nonlinear gravitational evolution, are computationally prohibitive. They demand massive resources for high-resolution runs, creating a trade-off between simulation volume, mass resolution, and the number of realizations. While approximate methods (e.g., COLA, FastPM) exist, they often lack precision in the deeply nonlinear regime. Machine learning (ML) offers a potential solution, but existing models often struggle with scalability, redshift flexibility, or the accurate reconstruction of small-scale non-Gaussian features.

2. Methodology: TUNeS Framework

The authors introduce TUNeS (Temporal UNet emulator for Structure formation), a neural network framework designed to accelerate N-body simulations by predicting the nonlinear evolution of the matter density field from an initial particle distribution. The framework operates directly on particle data and supports arbitrary input and target redshifts.

A. Two-Stage Modeling Strategy

TUNeS employs a hybrid approach that separates large-scale linear evolution from small-scale nonlinear refinement:

Stage 1: Particle-Based Inference (Coarse Prediction)
- Input: Initial particle positions ( $x_{ini}$ ), velocities ( $v_{ini}$ ), and redshift pairs ( $z_{ini}, z_{fin}$ ).
- Architecture: A feature-wise linear modulation (FiLM) residual Multilayer Perceptron (MLP).
- Mechanism: The model predicts coarse particle displacements ( $\Delta x$ ) without explicitly computing particle-particle interactions. It uses Fourier features for position encoding and FiLM layers to modulate features based on temporal information (logarithmic scale factors).
- Output: A coarse estimate of the particle distribution at the target redshift. This stage captures bulk motions and large-scale structures, analogous to the Zel'dovich approximation but learned from data.
Stage 2: Density-Field Refinement (Fine Prediction)
- Input: The coarse particle distribution from Stage 1 is converted into a 3D density field using Cloud-in-Cell (CIC) assignment. This field is decomposed into overlapping spatial windows.
- Architecture: A 3D U-Net convolutional neural network.
- Mechanism: The U-Net refines the density field to capture nonlinear evolution and small-scale structures. It uses an encoder-decoder structure with skip connections and 3D FiLM conditioning to handle redshift dependence.
- Output: Refined density windows that are stitched together to form a continuous full-volume density field.

B. Scalability and Windowing

To handle large volumes without exceeding GPU memory limits, TUNeS uses a window-based strategy:

The density field is processed in overlapping windows (e.g., $128^3$ voxels).
A tent-shaped weighting function is used during reconstruction to suppress boundary artifacts when stitching windows together.
This allows the model to scale to arbitrarily large simulation volumes and irregular geometries without increasing peak GPU memory usage.

C. Training Details

Dataset: Trained on 8 N-body simulations (initialized at $z=100$ ) with $256^3$ particles in a $500 \, h^{-1}\text{Mpc}$ box using the $\Lambda$ CDM cosmology.
Loss Functions:
- Stage 1: Mean Squared Error (MSE) on particle displacements.
- Stage 2: Spatially weighted MSE on density voxels, down-weighting boundary regions to minimize stitching artifacts.
Optimizer: AdamW with learning rate scheduling (StepLR for Stage 1, Cosine Annealing for Stage 2).

3. Key Contributions

Redshift Flexibility: Unlike grid-based emulators tied to specific initial conditions, TUNeS operates on particle distributions, allowing it to propagate density fields from arbitrary intermediate redshifts (demonstrated here from $z=100$ to $z \in [0, 6]$ ).
Hybrid Architecture: The combination of particle-based MLPs for large-scale dynamics and U-Nets for small-scale refinement balances physical interpretability with the representational power of CNNs.
Scalability: The window-based decomposition enables inference on volumes larger than the training domain without increasing memory costs.
Efficiency: The model achieves high accuracy with a small training set (only 8 simulations) and runs on consumer-grade hardware.

4. Results and Performance

The model was evaluated against reference N-body simulations using a comprehensive suite of statistical metrics:

Visual Comparison: Predicted density slices show excellent visual agreement with N-body results, reproducing both large-scale filaments and small-scale clumps.
One-Point Statistics (PDF): The probability distribution function of the overdensity field matches the reference within 2% relative error for intermediate densities ( $\delta \in [-0.5, 2]$ ).
Two-Point Statistics (Power Spectrum):
- The power spectrum error remains at the few-percent level up to $k \simeq 1 \, h \text{Mpc}^{-1}$ .
- Phase errors (stochasticity) are below 5% for $z \gtrsim 1$ at $k \simeq 1 \, h \text{Mpc}^{-1}$ .
Non-Gaussian Statistics:
- Peak Counts: Abundance of local maxima matches reference results within 10% for signal-to-noise ratios $S/N \lesssim 3$ .
- Minkowski Functionals: The model accurately reproduces volume, surface area, mean curvature, and Euler characteristic, with discrepancies typically an order of magnitude smaller than the absolute values of the functionals.
Runtime and Memory:
- Inference Time: $\sim 25$ seconds for a full-volume inference ( $256^3$ particles to $256^3$ grid) on a single NVIDIA RTX 4090 GPU.
- Memory Usage: Peak GPU memory is $\sim 4$ GB.

5. Significance and Future Directions

TUNeS represents a significant step forward in cosmological emulation by offering a fast, accurate, and scalable alternative to traditional N-body simulations. Its ability to run on a single consumer GPU with low memory requirements makes it accessible for generating large ensembles of realizations needed for:

Weak gravitational lensing analyses.
Cosmological parameter inference.
Non-Gaussian statistics studies.

Future Work: The authors plan to train on larger datasets with higher resolution to improve small-scale accuracy, extend the framework to modified gravity and multi-component matter models, and apply it to light-cone simulations and observational data analysis.