Skip to main content Início Criadores 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.
Ir para a instalação Skills Marketplace Descubra e explore skills de IA criadas pela comunidade.
Instalar com Codex ou Claude Copie este prompt, cole no Codex, Claude ou outro assistente e deixe que ele revise a página da skill e instale para você.
Mostrar detalhes do prompt Um comando direto ignora o prompt de revisão. Verifique a origem antes de executá-lo.
npx skills add https://github.com/hiyenwong/ai_collection --skill dysco-latent-dynamics-extractionO comando permanece em uma só linha. Role horizontalmente para revisá-lo antes de copiar.
Prefere uma cópia local? Baixe os arquivos disponíveis atualmente no SkillsMP.
Baixar Zip Baixando... Ocupações relacionadas SOC
Baseado na classificação ocupacional SOC
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.
