Skip to main content Home Creators hiyenwong ai_collection dysco-latent-dynamics-extraction
dysco-latent-dynamics-extraction DYSCO (Dynamics via Contrastive Learning) - Multi-view temporal contrastive learning for extracting governing equations from latent dynamics. Identifies dynamical systems from noisy high-dimensional observations with theoretical identifiability guarantees.
Jump to install Skills Marketplace Discover and explore AI skills built by the community.
Install with Codex or Claude Copy this prompt, paste it into Codex, Claude, or another assistant, and let it review the skill page and install it for you.
Show prompt details A direct command skips the review prompt. Inspect the source before running it.
npx skills add https://github.com/hiyenwong/ai_collection --skill dysco-latent-dynamics-extractionThe command stays on one line. Scroll horizontally to inspect it before copying.
Prefer a local copy? Download the files currently available to SkillsMP.
Download Zip Downloading... More from this repository Related occupations SOC
Based on SOC occupation classification
name dysco-latent-dynamics-extraction description DYSCO (Dynamics via Contrastive Learning) - Multi-view temporal contrastive learning for extracting governing equations from latent dynamics. Identifies dynamical systems from noisy high-dimensional observations with theoretical identifiability guarantees. keywords ["contrastive learning","dynamical systems","latent dynamics","governing equations","system identification","neural recordings","representation learning","scientific discovery","multi-view learning"] version 1.0.0 arxiv_id 2606.1326 authors Paolo Muratore, Mackenzie Weygandt Mathis published 2026-06-11T00:00:00.000Z categories ["cs.LG","q-bio.NC"]
DYSCO: Extracting Governing Equations from Latent Dynamics via Multi-View Contrastive Learning
Overview
This paper presents DYSCO , a multi-view temporal contrastive learning algorithm that jointly recovers latent trajectories and governing dynamics from noisy, high-dimensional measurements. The framework enables symbolic recovery of governing equations within an affine gauge with theoretical identifiability guarantees.
Key Innovation : Multi-view contrastive learning + functional basis parameterization → disentangle signal from noise + recover symbolic dynamics
Core Question : How can we identify latent dynamical systems from noisy, high-dimensional observations (e.g., neural recordings)?
Methodology
1. Multi-View Contrastive Learning Framework
Core Idea : Use multiple independent noisy views of same underlying process to separate signal from noise
y_t^i = g_i(x_t) + ε_t^i
Key Assumption : Views are independent conditioned on latent state
2. Contrastive Learning Objective
Temporal contrastive loss :
L_contrastive = -log(exp(sim(x_t, x_{t+τ}) / τ)
/ Σ_s exp(sim(x_t, x_s) / τ))
Positive pairs : (x_t, x_{t+τ}) - temporally adjacent samples (same trajectory)
Negative pairs : (x_t, x_s) - samples from different trajectory segments
3. Functional Basis Parameterization
Dynamics representation :
dx/dt = f(x) = Σ_{k=1 }^K θ_k · φ_k(x)
Advantages :
Structured parameterization → symbolic recovery
Sparse basis → interpretable equations
Flexible basis → adapts to dynamics complexity
4. Joint Optimization
L_total = L_contrastive + L_reconstruction + λ·L_sparsity
Mathematical Framework
1. Identifiability Theory Main Theorem : Under multi-view assumption with independent noise:
The latent trajectory x_t and dynamics f(x) are identifiable
up to affine transformation:
x̂_t = A·x_t + b
f̂(x̂) = A·f(A^{-1}(x̂ - b))
Key Result : Extends identifiability to realistic noisy nonlinear observations
2. Affine Gauge Freedom
x̂ = A·x + b (A invertible, b arbitrary)
f̂(x̂) = A·f(A^{-1 }(x̂ - b))
3. Noise Disentanglement Mechanism Mathematical guarantee : Independent noise cancels out in contrastive objective
Computational Implementation
1. DYSCO Architecture class DYSCO :
def __init__ (self,
encoder_dim,
basis_functions,
K_views ):
self .encoders = [Encoder(view_dim, encoder_dim)
for _ in range (K_views)]
self .dynamics = DynamicsBasis(encoder_dim, basis_functions)
self .decoders = [Decoder(encoder_dim, view_dim)
for _ in range (K_views)]
def forward (self, observations ):
latents = [encoder(obs) for encoder, obs
in zip (self .encoders, observations)]
x_t = aggregate_latents(latents)
dx_dt = self .dynamics(x_t)
reconstructions = [decoder(x_t) for decoder in self .decoders]
return x_t, dx_dt, reconstructions
2. Training Procedure def train_dysco (model, data, epochs ):
"""
Multi-view contrastive learning for dynamics extraction.
Parameters:
- model: DYSCO instance
- data: Multi-view observations {y_t^1, ..., y_t^K}
- epochs: Training iterations
"""
optimizer = torch.optim.Adam(model.parameters())
for epoch in range (epochs):
t = random_time_index()
τ = random_delay()
pos_pairs = [(data[t], data[t+τ]) for view in data.views]
s = random_different_index()
neg_pairs = [(data[t], data[s]) for view in data.views]
L_contr = contrastive_loss(pos_pairs, neg_pairs)
L_recon = reconstruction_loss(data, model.reconstruct(data))
L_sparse = torch.norm(model.dynamics.coefficients, p=1 )
L_total = L_contr + L_recon + λ·L_sparse
optimizer.zero_grad()
L_total.backward()
optimizer.step()
3. Symbolic Equation Recovery def extract_governing_equations (model, basis_functions ):
"""
Extract symbolic governing equations from learned dynamics.
Returns:
- equation_str: Symbolic equation (e.g., "dx/dt = -x + x^3")
"""
coefficients = model.dynamics.coefficients.detach()
terms = []
for k, (coeff, basis_func) in enumerate (zip (coefficients, basis_functions)):
if abs (coeff) > threshold:
terms.append(f"{coeff:.3 f} ·{basis_func.name} " )
equation_str = "dx/dt = " + " + " .join(terms)
return equation_str
Core Findings
1. Accurate Recovery Across Dynamical Regimes
Chaotic : Lorenz system, Rössler attractorOscillatory : Van der Pol, Stuart-LandauMetastable : Double-well potential, Switching systems Results : High accuracy for both latent trajectories and flow fields
2. Robustness to Observation Noise
Gaussian noise : Additive white noise (σ = 0.1 to 1.0)Poisson noise : Neural recording realistic (spike-count noise) Key Finding : Poisson noise robustness particularly relevant for neural data
3. Affine Indeterminacy Handling
x̂_canonical = (x̂ - mean(x̂)) / std(x̂)
f̂_canonical = std(x̂)·f̂
Applications
1. Neural Recording Analysis Use case : Extract dynamics from calcium imaging / electrophysiology
neural_dynamics = DYSCO(encoder_dim=50 , basis='polynomial' , K=3 )
neural_dynamics.train(neural_data)
equations = extract_governing_equations(neural_dynamics)
2. Scientific Discovery Pipeline Automated equation discovery :
views = collect_observations(experiment)
model = DYSCO.train(views)
candidates = extract_governing_equations(model)
validate_dynamics(candidates, perturbation_experiment)
3. Chaotic System Identification
extracted = "dx/dt = 10.2(y-x), dy/dt = x(28.1-z)-y, dz/dt = xy-2.67z"
Technical Details
1. Encoder Architecture class Encoder (nn.Module):
"""
View-specific encoder: y_t → x_t (latent)
Architecture options:
- MLP: Multi-layer perceptron (simple)
- TCN: Temporal Convolutional Network (temporal)
- Transformer: Self-attention based
"""
def __init__ (self, input_dim, latent_dim ):
self .network = nn.Sequential(
nn.Linear(input_dim, 256 ),
nn.ReLU(),
nn.Linear(256 , 128 ),
nn.ReLU(),
nn.Linear(128 , latent_dim)
)
def forward (self, observation ):
return self .network(observation)
2. Basis Function Selection Polynomial basis (for simple dynamics):
basis_functions = [
λ → 1 ,
λ → x_i,
λ → x_i·x_j,
λ → x_i·x_j·x_k,
]
Neural network basis (for complex dynamics):
basis_functions = NeuralBasis(
input_dim=latent_dim,
hidden_dim=64 ,
output_dim=K_basis
)
3. Sparsity Regularization
L_sparse = torch.norm(model.dynamics.coefficients, p=1 )
L_group_sparse = torch.norm(torch.stack([
torch.norm(coeff_group, p=2 )
for coeff_group in coefficient_groups
]), p=1 )
Experimental Validation
1. Synthetic Dynamics Test
true_dynamics = Lorenz(sigma=10 , rho=28 , beta=2.67 )
observations = generate_multiview(true_dynamics, noise='Poisson' )
model = DYSCO.train(observations)
trajectory_error = MSE(model.latent, true_dynamics.trajectory)
flow_error = MSE(model.dynamics, true_dynamics.flow_field)
2. Neural Recording Test Dataset : Motor cortex recording during reaching task
Calcium imaging (ΔF/F)
Electrophysiology (spike trains)
Kinematic data (hand position)
Result : Recovered latent dynamics correlates with motor planning
Limitations & Extensions
Current Limitations
Affine indeterminacy : Cannot recover exact coordinates without normalizationView independence assumption : Requires truly independent noiseStationarity : Assumes dynamics don't change over timeBasis selection : Manual choice of basis functions
Future Extensions
Non-affine identifiability : Additional constraints to fix gaugeNon-independent noise : Robustness to correlated noise across viewsNon-stationary dynamics : Adaptive dynamics learningAutomatic basis discovery : Learn basis functions from data
Related Methods
System Identification
SINDy : Sparse Identification of Nonlinear Dynamics (Brunton et al.)Koopman operator : Linear embedding for nonlinear dynamicsDeep Koopman : Neural network Koopman approximation
Contrastive Learning
SimCLR : Contrastive learning for imagesTime-Contrastive Learning (TCL) : Temporal contrastiveMulti-view contrastive : CMC (Contrastive Multiview Coding)
Representation Learning
VAE : Variational autoencoder for latent dynamicsDynamic VAE : Time-series VAE variantsLatent ODE : Neural ODE in latent space
Key References
SINDy : Brunton et al. (2016) - "Discovering governing equations from data"Multi-view learning : Tian (2020) - "Contrastive multiview coding"Identifiability : Hyvarinen & Morioka (2016) - "Unsupervised feature extraction"Neural ODE : Chen et al. (2018) - "Neural ordinary differential equations"
Activation Keywords
"extract governing equations"
"latent dynamics identification"
"multi-view contrastive learning"
"system identification from neural recordings"
"dynamics discovery"
"DYSCO algorithm"
"affine identifiability"
"symbolic equation recovery"
"noisy observation dynamics"
"Poisson noise robustness"
Notes
8,809 KB, submitted June 11, 2026 - First submission, new methodFrom Mathis Lab (Caltech) - Known for behavioral neuroscience + MLCross-listed cs.LG + q-bio.NC - Bridges ML and neuroscienceNeural recording relevance : Poisson noise handling critical for spike dataNovel contribution : First multi-view contrastive approach for dynamics extraction with theoretical guarantees This skill enables extracting symbolic governing equations from noisy high-dimensional observations using multi-view temporal contrastive learning , with identifiability guarantees extending to realistic neural recording scenarios.
