Pipeline that maps noisy multichannel time-series observations to compact latent trajectories with a Hierarchical Linear Dynamical System (HLDS), then evaluates those trajectories for classification, separability, and stability.
I built a reproducible pipeline for a general signal-modeling problem: infer low-dimensional latent dynamics from noisy multichannel observations, then use those latent trajectories as inputs to a downstream classifier. The public description stays at the level of the model, evaluation protocol, and research artifacts.
A state-space pipeline for turning noisy multichannel observations into latent trajectories that a classifier can evaluate.
The problem: classify structure that is not directly observed
In many time-series problems, labels describe a class or regime while the observations are high-dimensional, noisy measurements. The useful representation is not given directly; it is a latent trajectory that evolves over time. This project asks whether a compact dynamical representation can make downstream classification more stable and interpretable than treating every window as an independent feature vector.
The goal is deliberately narrow: learn latent states, then test whether those states separate classes under a fixed evaluation protocol. The public page focuses on that technical problem rather than the application that motivated it.
Why a hierarchical dynamical system?
A Hierarchical Linear Dynamical System (HLDS) separates three things that are easy to conflate in a generic sequence model: what is observed, what is hidden, and how the hidden variables evolve. The hierarchy lets a small set of higher-level states summarize lower-level dynamics, while the linear-Gaussian structure keeps inference inspectable and data-efficient.
That structure gives the project useful failure modes. An unstable latent trajectory, a poor reconstruction, or a class boundary that disappears under held-out inference points to a different problem than a classifier score moving without explanation.
Figure 1 — The state-space view: a compact chain of hidden states evolves over time and generates the observed multichannel signal.
Training and inference are separate
The HLDS runs in two clearly separated phases. During training, a dual-Kalman procedure alternates between inferring hidden states and updating model parameters over multiple passes. During inference, those parameters are frozen and a Kalman-style recursion produces the latent trajectory for a new sequence.
Keeping the phases separate prevents a subtle evaluation leak: the classifier receives encodings produced under fixed parameters rather than a representation quietly re-fit to each held-out sequence.
Figure 2 — Training learns the dynamical parameters; inference freezes them and turns a new sequence into a latent trajectory for classification.
The pipeline around the model
Each experiment is a fixed sequence of stages so representation quality and classifier performance can be compared fairly:
Preprocessing
Clean, standardize, and align observed signals into consistent time windows.
Training
Fit HLDS transition and emission parameters with the dual-Kalman procedure.
Latent inference
Run the fixed model on held-out sequences to produce compact trajectories.
Classification
Evaluate whether the latent trajectories predict and separate the labeled classes.
Diagnostics
Check stability, reconstruction behavior, class separability, and run-to-run consistency.
Classification on latent trajectories
The classifier is intentionally downstream of the dynamical model. That makes it possible to ask two separate questions: did the HLDS learn a stable, useful representation, and do those representations contain information that separates the classes? Evaluation artifacts keep those questions visible instead of collapsing everything into one score.
Where it stands
The reproducible pipeline, HLDS training/inference phases, classifier evaluation, diagnostics, and standardized run artifacts are in place. The next iteration is continued comparison across evaluation splits and model settings, with attention to latent-state stability and out-of-sample separability.
The public claim is intentionally bounded: this is a general latent-signal classification framework. The source data and application context are not part of the public project description.
FAQ
What does latent signal mean here?
It means a lower-dimensional trajectory inferred from observed time-series measurements. The trajectory is not measured directly; the dynamical model estimates it from the observations and their temporal structure.
Why use a hierarchical dynamical system?
The hierarchy lets higher-level states summarize lower-level dynamics, while the state-space formulation makes transitions, emissions, and inference steps inspectable.
How does classification enter the pipeline?
The HLDS produces a latent trajectory for each held-out sequence. A downstream classifier then tests whether those trajectories contain information that separates the labeled classes.
Does this page report a benchmark result?
No. It describes the model and evaluation framework without publishing application-specific data, results, or claims that would identify the underlying study.
What I built
A reproducible data pipeline (loading → cleaning → segmentation → feature preparation) that turns observed time-series signals into model-ready inputs.
Training and evaluation scripts for a Hierarchical Linear Dynamical System (HLDS) that infers hidden variables evolving over time.
Diagnostics and scoring outputs for latent-trajectory stability, prediction, and class separability.
Automated summaries and artifacts so runs can be audited and compared (configuration capture, standardized outputs, and plots).
How it works
Observed signals are cleaned, standardized, and aligned into consistent time windows.
The HLDS learns hidden variables and transition structure that explain how those observations evolve.
At inference time, learned parameters are fixed and a Kalman-style recursion produces latent trajectories for held-out sequences.
A downstream classifier evaluates whether those latent trajectories separate the labeled classes under the same evaluation protocol.
Deliverables
Run folders with configs, logs, metrics, and plots.
A standardized summary table for comparing latent representations and classifiers across evaluation splits.
