Self-Supervised Learning via Flow-Guided Neural Operator on Time-Series Data

The paper introduces Flow-Guided Neural Operator (FGNO), a novel self-supervised learning framework that treats corruption levels as a dynamic degree of freedom and leverages flow matching with Short-Time Fourier Transform to learn versatile, multi-scale time-series representations, achieving significant performance improvements over baselines across diverse biomedical domains.

The Gist

Imagine you are trying to teach a computer to understand the rhythm of a human heartbeat, the patterns of a sleeping brain, or the fluctuations of a stock market. These are all time-series data—information that changes over time.

The problem is, we have tons of this data, but very little of it comes with "labels" (like a doctor saying, "This part is a seizure" or "This part is deep sleep"). To teach the computer, we usually need those labels. Self-Supervised Learning (SSL) is a clever trick that lets the computer learn from the unlabeled data first, figuring out the patterns on its own, before we ever show it the answers.

This paper introduces a new, smarter way to do this called FGNO (Flow-Guided Neural Operator). Here is how it works, broken down with simple analogies.

1. The Old Way: The "Fixed Mask" Game

Imagine you are trying to learn a language by reading a book where every 10th word is covered with a black sticker. You have to guess the missing words based on the context. This is how older methods (like Masked Autoencoders) work. They take a signal, cover up a fixed amount of it (say, 50%), and force the computer to "fill in the blanks."

The Problem: What if the book needs different levels of difficulty? Sometimes you need to guess just a few words to understand a sentence; other times, you need to understand the whole paragraph. The old method is stuck with one fixed sticker size. It's rigid.

2. The New Way: The "Flow" of Water

The authors propose a new idea: Treat the "corruption" (the missing parts or noise) like a dial you can turn.

Imagine the data is a clear glass of water.

• Level 0: The water is muddy and chaotic (lots of noise).
• Level 1: The water is crystal clear (the original data).

Instead of just picking one muddy level to practice on, FGNO teaches the computer to understand the entire journey from muddy to clear. It learns how the water "flows" from chaos to order. This is called Flow Matching.

3. The Secret Sauce: The "Spectrogram" Lens

Time-series data (like a heartbeat) is just a squiggly line. It's hard to see patterns in a line.
FGNO uses a tool called STFT (Short-Time Fourier Transform). Think of this as a special pair of glasses that turns the squiggly line into a colorful map (a spectrogram).

• Instead of just seeing "time," the computer sees time and frequency (like seeing the notes in a song, not just the rhythm).
• This is crucial because it lets the computer understand the data regardless of how fast or slow the signal was recorded. It's like being able to read a book whether it's printed in tiny font or huge font, without having to resize the pages.

4. The "Magic Dial": Choosing the Right View

Here is the coolest part. Because the computer learned the whole "flow" from muddy to clear, you can ask it to show you the data at any stage of that flow.

• Need to see tiny, fast details? (Like a sudden spike in a heart rate). You turn the dial to a "low noise" setting and look at the shallow layers of the network. It's like looking at the water when it's just starting to clear up—you see the fine ripples.
• Need to see the big picture? (Like a trend over a whole night of sleep). You turn the dial to a "high noise" setting and look at the deep layers. It's like looking at the water when it's very muddy; the small ripples are gone, but the big shape of the current is obvious.

The Analogy: Imagine a sculpture.

• If you look at it from far away (high noise/deep layer), you see the general shape of the head.
• If you walk up close (low noise/shallow layer), you see the texture of the skin and the eyelashes.
• FGNO lets you choose exactly how close you want to look, using the same model, without retraining it.

5. The "Clean Input" Surprise

Most generative AI methods say, "To get the answer, you must feed the computer a noisy, messy input."
FGNO says, "No thanks."

• Old Way: You give the computer a blurry photo and ask, "What is this?" (The computer has to guess the blur).
• FGNO Way: You give the computer a crystal clear photo and say, "Tell me what you see if we pretend this photo is slightly blurry."
• Why it matters: This removes the randomness. The answer is always the same, making it more accurate and reliable for real-world medical use.

6. Why This Matters (The Results)

The authors tested this on real medical data:

• Sleep Analysis: It figured out sleep stages better than previous methods, even when they only had 5% of the labeled data (a huge win for saving money and time).
• Brain Signals: It decoded brain activity from movies much faster and more accurately.
• Temperature Prediction: It predicted skin temperature with much less error.

Summary

FGNO is like a Swiss Army knife for time-series data.

1. It translates data into a universal map (Spectrogram) so speed doesn't matter.
2. It learns the "flow" from chaos to clarity, rather than just filling in one fixed gap.
3. It lets you dial in exactly the level of detail you need (tiny ripples vs. big waves) for your specific task.
4. It works with clean data, making it stable and reliable.

It's a smarter, more flexible way to teach computers to understand the rhythms of our world, especially when we don't have enough labeled examples to teach them the hard way.

Technical Summary

1. Problem Statement

Time-series data is ubiquitous in domains like healthcare and weather forecasting, but learning useful representations is challenging due to:

• Label Scarcity: Supervised learning is often infeasible due to the high cost of annotating medical or sensor data.
• Heterogeneity: Real-world signals are recorded at varying sampling rates (e.g., 4 Hz to 200 Hz). Standardizing these via up/down-sampling often distorts intrinsic characteristics or blurs fine-grained events (e.g., micro-arousals).
• Multi-Scale Requirements: Different downstream tasks require representations at different temporal and semantic scales (e.g., local patterns for sleep staging vs. global trends for clinical forecasting).
• Limitations of Existing SSL:
  • Masked Autoencoders (MAE): Rely on a fixed, static masking ratio, limiting flexibility.
  • Generative SSL (Diffusion/Flow): Often require noisy inputs during inference, introducing randomness and potential information loss.
  • Foundation Models: While powerful, many are optimized for forecasting or fixed resolutions, lacking adaptability for diverse discriminative tasks.

2. Methodology: Flow-Guided Neural Operator (FGNO)

The authors propose FGNO, a self-supervised framework that combines Neural Operators with Flow Matching.

A. Core Architecture & Pre-training

• Input Embedding (STFT): Instead of processing raw 1D signals, FGNO converts input time-series $x$ into magnitude spectrograms using the Short-Time Fourier Transform (STFT). This creates a time-frequency representation that is resolution-invariant, allowing the model to handle different sampling rates without interpolation distortion.
• Flow Matching Objective: The model is pre-trained using a flow-matching paradigm. It learns a vector field that maps a simple noise distribution (Gaussian) to the complex data distribution (spectrograms).
  • For a clean data function $\phi$ and a flow time $s \in [0, 1]$, a noisy intermediate state $g$ is constructed: $g = s\phi + \sigma_s \epsilon$.
  • The neural network $u_\theta(s, g)$ is trained to predict the target vector field that guides the denoising process from noise back to data.
• Neural Operator Design: The backbone is a Transformer conditioned on the flow time $s$. Unlike standard operators that map fixed-size vectors, FGNO learns mappings in function space, enabling generalization across resolutions.

B. Feature Extraction & Probing (Inference)

A key innovation is the deterministic extraction of representations using clean inputs:

• Clean Input Strategy: Unlike prior generative methods that feed noisy data during inference, FGNO feeds the clean spectrogram $\phi$ into the frozen pre-trained model, conditioning it on a specific flow time $s$.
• Hierarchical Features: The model outputs a hierarchy of features $z_{l,s}(\phi)$ based on the network layer $l$ and flow time $s$:
  • Low $s$ (High corruption) + Shallow layers: Capture fine-grained, local temporal details.
  • High $s$ (Low corruption) + Deep layers: Capture abstract, global semantic features.
• Adaptive Selection: For a specific downstream task, a lightweight probing head (classifier/regressor) is trained on top of the frozen backbone. The optimal pair $(l^*, s^*)$ is selected via grid search to minimize validation loss, allowing the single model to adapt to tasks requiring different levels of abstraction.

3. Key Contributions

1. Unified Framework: Combines flow matching and neural operators to learn time-series representations in function space, preserving multi-scale fidelity without resampling.
2. Flow Time as a Control Knob: Introduces flow time $s$ and network layer $l$ as tunable degrees of freedom to explicitly control representation granularity (from local textures to global semantics).
3. Clean Input Inference: Demonstrates that using clean inputs for representation extraction (rather than noisy inputs) eliminates randomness, improves stability, and yields superior performance.
4. Resolution Agnosticism: By operating on STFT spectrograms, the model generalizes effectively to different sampling rates, outperforming baselines even under extreme downsampling.

4. Experimental Results

FGNO was evaluated on four biomedical datasets: DREAMT (sleep/temperature), BrainTreeBank (neural decoding), SleepEDF, and Epilepsy.

• Performance Gains:
  • BrainTreeBank: Achieved up to 35% improvement in AUROC for neural signal decoding compared to baselines (MAE, BrainBERT).
  • DREAMT: Reduced RMSE by 16% for skin temperature prediction compared to MAE.
  • SleepEDF/Epilepsy: Under low-data regimes (only 5% labeled data), FGNO maintained ~93.5% accuracy and ~89.0% macro-F1, outperforming strong baselines by over 20% and matching full-data performance.
• Efficiency:
  • FGNO uses only 370K parameters (vs. 20M+ for baselines) yet achieves state-of-the-art results.
  • Downstream adaptation (probing) is 60% faster than full fine-tuning of baselines.
• Robustness to Resolution: On BrainTreeBank, FGNO maintained >74% AUROC even with 48x downsampling, whereas MAE dropped to ~52% and Chronos fluctuated around 60%.

5. Significance

• Data Efficiency: FGNO is exceptionally robust in data-scarce scenarios, making it highly suitable for biomedical applications where labeled data is expensive and rare.
• Flexibility: The ability to tune the "flow time" allows a single pre-trained model to serve diverse tasks (e.g., classification vs. regression) without retraining the backbone.
• Paradigm Shift: The work challenges the standard generative SSL practice of using noisy inputs for inference, proving that learning with noise but inferring with clean data yields more stable and accurate representations.
• Generalization: By treating time-series as functions via STFT, FGNO overcomes the "resolution mismatch" problem that plagues many existing time-series foundation models.

In conclusion, FGNO represents a significant advancement in self-supervised time-series learning, offering a scalable, efficient, and highly adaptable solution for extracting rich representations from unlabeled biomedical data.