📊 statistics

NeuralFLoC: Neural Flow-Based Joint Registration and Clustering of Functional Data

NeuralFLoC is a fully unsupervised, end-to-end deep learning framework that jointly performs functional registration and clustering using Neural ODE-driven diffeomorphic flows and spectral clustering to effectively disentangle phase and amplitude variations while achieving state-of-the-art performance and robustness.

Original authors: Xinyang Xiong, Siyuan jiang, Pengcheng Zeng

Published 2026-04-30

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Xinyang Xiong, Siyuan jiang, Pengcheng Zeng

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 you are trying to organize a choir where every singer is singing the same song, but some are singing slightly faster, some slower, and some are starting their high notes a beat late. If you just look at the raw sound waves, the singers who are out of sync will look completely different from the ones who are on time, even if they are singing the same melody. This makes it incredibly hard to group the singers by who they are (their unique voice) rather than when they are singing.

In the world of data science, this is called Functional Data Analysis. The "singers" are curves or lines (like heartbeats, stock prices, or handwriting), and the "timing issues" are called phase variation.

The paper introduces a new tool called NeuralFLoC (Neural Flow-based Joint Registration and Clustering). Here is how it works, using simple analogies:

The Problem: The "Messy Timeline"

Imagine you have a stack of photos of a flower blooming. In some photos, the flower is just opening; in others, it's fully open. If you try to sort these photos into "groups" based on how they look, you might accidentally group a "half-open" photo from Group A with a "half-open" photo from Group B, just because they look similar at that specific moment. But actually, they belong to different types of flowers.

The timing (phase) is messing up the shape (amplitude). Traditional methods try to fix the timing first, then sort the photos. But if you fix the timing wrong, the sorting will be wrong too. It's a "chicken and egg" problem.

The Solution: NeuralFLoC

NeuralFLoC is a smart, unsupervised AI system that does two things at the same time:

It fixes the timing (Registration).
It sorts the groups (Clustering).

It treats these two tasks as partners that help each other, rather than separate steps.

1. The "Stretchy Rubber Band" (Neural ODEs)

To fix the timing, the system uses something called Neural ODEs (Neural Ordinary Differential Equations).

The Analogy: Imagine the timeline of your data is a stretchy rubber band. Some parts need to be stretched, and some need to be squished to make the curves line up perfectly.
How it works: Instead of just snapping the rubber band into place (which can cause jagged, unnatural breaks), NeuralFLoC uses a "flow" to gently stretch and smooth the band. It guarantees that the band never tears or folds back on itself (mathematically, this means the transformation is "smooth and invertible"). This ensures the data stays physically realistic.

2. The "Group Leaders" (Spectral Clustering)

Once the rubber bands are stretched to line up, the system needs to decide which curves belong together.

The Analogy: Imagine the system creates a "Group Leader" (a template) for each cluster. As the system learns, it asks: "Does this curve look more like the Leader of Group A or Group B?"
The Magic: It doesn't just guess. It uses a "soft assignment" system. It says, "This curve is 80% Group A and 20% Group B." Then, it uses that guess to adjust the rubber band stretching again. If the curve looks more like Group A, the system stretches the rubber band to make it fit Group A's leader even better.

Why is this better than the old ways?

Old Way (Two Steps): First, you force all curves to line up with a generic "average" curve. Then, you try to sort them. If your "average" curve was a bad guess, the whole process fails.
NeuralFLoC (One Step): It learns the "Group Leaders" while it is stretching the rubber bands. The stretching helps the sorting, and the sorting helps the stretching. They feed back into each other like a conversation.

What did they test?

The authors tested this on various real-world data sets, including:

Shapes: Images of object boundaries.
Wave: Motion sensor data (like how a phone moves when you wave it).
Symbols: Handwriting trajectories.

They found that NeuralFLoC was better at:

Aligning the curves: Making the "singers" hit the same notes at the same time.
Sorting the groups: Correctly identifying which curves belonged to which category.
Handling messiness: It worked well even when data was missing, sampled at weird times, or had noise (static) in it.

The Bottom Line

NeuralFLoC is like a smart editor that doesn't just fix the timing of a messy recording; it figures out who the different singers are while it fixes the timing. By doing both jobs together using smooth, mathematical "flows," it gets a much clearer picture of the data than previous methods that tried to do the jobs separately.

The paper claims this is the first time a deep learning system has successfully combined these two specific tasks (fixing time-warping and clustering) in a single, end-to-end framework, and it proves mathematically that it works reliably as you add more data.

1. Problem Statement

The paper addresses the challenge of clustering functional data (e.g., biological signals, motion paths) in the presence of phase variation.

The Core Issue: Functional data often exhibit two types of variability: amplitude variation (vertical magnitude differences) and phase variation (horizontal/temporal misalignment of features).
The Difficulty: Standard clustering algorithms fail when phase variation is significant because they group curves based on temporal misalignment rather than intrinsic shape differences.
Limitations of Existing Methods:
- Two-stage approaches: Perform registration (alignment) and clustering separately. This leads to error propagation, bias from pre-specified templates, and computational inefficiency.
- Joint statistical models: Often rely on restrictive parametric assumptions (e.g., simple time shifts, Dirichlet processes) and struggle with scalability or multivariate data.

2. Methodology: NeuralFLoC

The authors propose NeuralFLoC, a fully unsupervised, end-to-end deep learning framework that integrates Neural Ordinary Differential Equations (Neural ODEs) with spectral clustering. The framework consists of three main modules:

A. Latent Initialization (1D-CNN Encoder)

Raw functional data $x_i(t)$ is passed through a 1D Convolutional Neural Network (CNN) to extract local morphological patterns.
The output is a latent vector $z_i$ which serves as the initial condition for the subsequent warping dynamics. This ensures alignment begins from a shape-aware representation.

B. Continuous Time-Warping (Neural ODE Warper)

Instead of discrete warping, the model learns smooth, invertible warping functions $\gamma_i(t)$ using Neural ODEs.
Mechanism: A learnable velocity field $f$ (parameterized by an MLP) governs the continuous flow $\tau_i(t)$ :
$\frac{d\tau_{ij}(t)}{dt} = f(\tau_{ij}(t), t, z_{ij}; \Theta_{ode})$
Constraints: A Softplus activation ensures the derivative is positive ( $\dot{\gamma} > 0$ ), guaranteeing the warping function is strictly monotonic and invertible (a diffeomorphism).
Cluster-Aware Mixing: The final warping function for a sample is a mixture of cluster-specific flows weighted by soft assignment probabilities $p_{ij}$ , allowing the alignment to be guided by the cluster structure.

C. Spectral Clustering & Objective Function

Alignment: The aligned curves are transformed into the Square Root Velocity Function (SRVF) space. This metric is invariant to re-parameterization, allowing for geometrically meaningful distance calculations.
Clustering: Aligned curves are projected onto a Fourier basis to filter noise and extract spectral coefficients. A soft-assignment mechanism (using a Student's t-distribution kernel) assigns curves to cluster centroids.
Joint Loss Function: The model minimizes a unified objective:
$\mathcal{L}_{total} = \mathcal{L}_{reg} + \alpha \mathcal{L}_{clu}$
- $\mathcal{L}_{reg}$ : Cluster-conditional SRVF registration loss (minimizing distance to cluster-specific Karcher means).
- $\mathcal{L}_{clu}$ : Clustering loss (Kullback-Leibler divergence between soft assignments and a target distribution) to encourage confident cluster separation.
- $\alpha$ : A balancing hyperparameter.

3. Key Contributions

Novel Framework: The first end-to-end deep learning approach for simultaneous functional registration and clustering.
Diffeomorphic Flows: Utilizes Neural ODEs to guarantee smooth, invertible, and monotonic warping functions without explicit distributional assumptions, overcoming the limitations of discrete or parametric methods.
Theoretical Guarantees:
- Universal Approximation: Proves that the Neural ODE module can approximate any admissible warping function arbitrarily well.
- Asymptotic Consistency: Establishes that the joint estimator converges to the true cluster assignments as sample size increases, provided clusters are separable after registration.
Scalability: Achieves linear time complexity $O(N)$ with respect to sample size and constant memory usage via the adjoint sensitivity method, making it suitable for large datasets.

4. Experimental Results

The method was evaluated on diverse datasets from the UCR Time Series Archive (Shapes, Wave, Symbols) involving both univariate and multivariate functional data.

Performance: NeuralFLoC achieved State-of-the-Art (SOTA) results in both registration (measured by Adjusted Total Variance, ATV) and clustering (Accuracy and Normalized Mutual Information).
Ablation Studies:
- Replacing the Neural ODE with discrete warping (SrvfRegNet) significantly degraded performance, highlighting the importance of continuous flows.
- Removing either the registration or clustering module caused severe performance drops, confirming the necessity of the joint formulation.
Robustness: The model demonstrated strong robustness to:
- Missing Data: Maintained performance with up to 20% missing points.
- Irregular Sampling: Performed well on unevenly sampled grids.
- Noise: Remained stable under Gaussian noise levels up to $\sigma=0.10$ .
Scalability: Successfully scaled to ~70,000 samples with minimal performance degradation.

5. Significance

NeuralFLoC represents a paradigm shift in Functional Data Analysis (FDA) by unifying geometric registration and unsupervised learning.

Disentanglement: It effectively separates phase and amplitude variations, a critical step often ignored or handled poorly in previous methods.
Flexibility: By avoiding restrictive parametric assumptions, it can model complex, non-linear temporal distortions common in real-world biological and physical systems.
Practicality: Its computational efficiency and robustness make it applicable to large-scale, noisy, and irregularly sampled functional datasets where traditional statistical methods fail.

In summary, NeuralFLoC provides a principled, scalable, and highly effective solution for analyzing misaligned functional data, bridging the gap between deep learning flexibility and the geometric rigor required for functional data analysis.