菜单
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.
默认使用会先检查来源的 Prompt；你也可以切换为直接命令，或下载本地副本。
决定是否安装前，请先阅读 SKILL.md，以及 SkillsMP 当前展示的配套文件。
用 Codex 或 Claude 帮你安装 复制这段 Prompt，粘贴到 Codex、Claude 或其他助手里，让它检查 Skill 页面并帮你完成安装。
直接命令不会经过审查 Prompt；运行前请先检查来源。
npx skills add https://github.com/hiyenwong/ai_collection --skill dysco-latent-dynamics-extraction命令会保持在同一行。复制前请横向滚动并检查完整内容。
想先保存到本地？可下载 SkillsMP 当前能够提供的文件。
基于 SOC 职业分类
正在显示 SKILL.md
| 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"] |
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)?
Core Idea: Use multiple independent noisy views of same underlying process to separate signal from noise
# Problem formulation
y_t^i = g_i(x_t) + ε_t^i # i = 1, 2, ..., K views
# x_t: latent trajectory (unknown)
# g_i: observation function (nonlinear, unknown)
# ε_t^i: observation noise (Gaussian or Poisson)
Key Assumption: Views are independent conditioned on latent state
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
Dynamics representation:
dx/dt = f(x) = Σ_{k=1}^K θ_k · φ_k(x)
# φ_k: basis functions (polynomial, neural network, etc.)
# θ_k: coefficients to identify
Advantages:
Loss function:
L_total = L_contrastive + L_reconstruction + λ·L_sparsity
# L_contrastive: disentangles signal from noise
# L_reconstruction: ensures latent encodes observations
# L_sparsity: encourages interpretable equations
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
Transformation family:
# Any affine transformation preserves dynamics structure
x̂ = A·x + b (A invertible, b arbitrary)
# Governing equations transform accordingly
f̂(x̂) = A·f(A^{-1}(x̂ - b))
# Example: Simple rotation/translation
# x̂ = R·x + c → f̂(x̂) = R·f(R^T(x̂ - c))
Why multi-view works:
# Single view: y_t = g(x_t) + ε_t
# Cannot separate signal g(x_t) from noise ε_t
# Multi-view: y_t^1 = g_1(x_t) + ε_t^1
# y_t^2 = g_2(x_t) + ε_t^2
# Contrastive learning finds x_t by:
# - Maximizing agreement across views (signal)
# - Minimizing agreement within noise (independent)
Mathematical guarantee: Independent noise cancels out in contrastive objective
class DYSCO:
def __init__(self,
encoder_dim, # Latent dimension
basis_functions, # φ_k for dynamics
K_views): # Number of views
# Encoders for each view
self.encoders = [Encoder(view_dim, encoder_dim)
for _ in range(K_views)]
# Dynamics parameterization
self.dynamics = DynamicsBasis(encoder_dim, basis_functions)
# Decoders for reconstruction
self.decoders = [Decoder(encoder_dim, view_dim)
for _ in range(K_views)]
def forward(self, observations):
# observations: {y_t^i} for i = 1..K
# Encode to latent
latents = [encoder(obs) for encoder, obs
in zip(self.encoders, observations)]
# Aggregate multi-view (average for signal extraction)
x_t = aggregate_latents(latents)
# Predict dynamics
dx_dt = self.dynamics(x_t)
# Reconstruct observations
reconstructions = [decoder(x_t) for decoder in self.decoders]
return x_t, dx_dt, reconstructions
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):
# Sample positive pairs (temporally adjacent)
t = random_time_index()
τ = random_delay() # Small temporal shift
pos_pairs = [(data[t], data[t+τ]) for view in data.views]
# Sample negative pairs (different trajectory segments)
s = random_different_index()
neg_pairs = [(data[t], data[s]) for view in data.views]
# Compute contrastive loss
L_contr = contrastive_loss(pos_pairs, neg_pairs)
# Reconstruction loss
L_recon = reconstruction_loss(data, model.reconstruct(data))
# Dynamics sparsity loss (L1 on coefficients)
L_sparse = torch.norm(model.dynamics.coefficients, p=1)
# Total loss
L_total = L_contr + L_recon + λ·L_sparse
optimizer.zero_grad()
L_total.backward()
optimizer.step()
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()
# Build equation string
terms = []
for k, (coeff, basis_func) in enumerate(zip(coefficients, basis_functions)):
if abs(coeff) > threshold: # Sparse selection
terms.append(f"{coeff:.3f}·{basis_func.name}")
equation_str = "dx/dt = " + " + ".join(terms)
return equation_str
Tested dynamics:
Results: High accuracy for both latent trajectories and flow fields
Noise types tested:
Key Finding: Poisson noise robustness particularly relevant for neural data
Practical approach:
# Identify dynamics up to affine transformation
# Use canonical normalization to fix gauge:
x̂_canonical = (x̂ - mean(x̂)) / std(x̂)
f̂_canonical = std(x̂)·f̂ # Scale-adjusted dynamics
Use case: Extract dynamics from calcium imaging / electrophysiology
# Multi-view setup:
# View 1: Calcium fluorescence (ΔF/F)
# View 2: Electrophysiology (spike trains)
# View 3: Behavioral correlates
neural_dynamics = DYSCO(encoder_dim=50, basis='polynomial', K=3)
neural_dynamics.train(neural_data)
# Extract governing equations of neural dynamics
equations = extract_governing_equations(neural_dynamics)
Automated equation discovery:
# Step 1: Multi-view data collection
views = collect_observations(experiment)
# Step 2: Train DYSCO
model = DYSCO.train(views)
# Step 3: Extract candidate equations
candidates = extract_governing_equations(model)
# Step 4: Validate experimentally
validate_dynamics(candidates, perturbation_experiment)
Lorenz system recovery:
# True dynamics: dx/dt = σ(y-x), dy/dt = x(r-z)-y, dz/dt = xy-bz
# DYSCO recovery from noisy observations:
extracted = "dx/dt = 10.2(y-x), dy/dt = x(28.1-z)-y, dz/dt = xy-2.67z"
# High parameter accuracy (σ≈10, r≈28, b≈2.67)
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)
Polynomial basis (for simple dynamics):
basis_functions = [
λ → 1, # constant
λ → x_i, # linear
λ → x_i·x_j, # quadratic
λ → x_i·x_j·x_k, # cubic
]
Neural network basis (for complex dynamics):
basis_functions = NeuralBasis(
input_dim=latent_dim,
hidden_dim=64,
output_dim=K_basis
)
# L1 regularization for sparse equation discovery
L_sparse = torch.norm(model.dynamics.coefficients, p=1)
# Alternative: Group sparsity for interpretable terms
L_group_sparse = torch.norm(torch.stack([
torch.norm(coeff_group, p=2)
for coeff_group in coefficient_groups
]), p=1)
Setup:
# Generate multi-view observations from known dynamics
true_dynamics = Lorenz(sigma=10, rho=28, beta=2.67)
observations = generate_multiview(true_dynamics, noise='Poisson')
# Train DYSCO
model = DYSCO.train(observations)
# Measure recovery accuracy
trajectory_error = MSE(model.latent, true_dynamics.trajectory)
flow_error = MSE(model.dynamics, true_dynamics.flow_field)
Dataset: Motor cortex recording during reaching task
Views:
Result: Recovered latent dynamics correlates with motor planning
Trigger phrases:
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.