Matlab Prepare Signal Data

MathWorksOfficialCreated by MathWorks

Skill
Tool integration
Data and AI
BSD-2-Clause
No issues found

From the author

Use this skill when conditioning, loading, preparing, or labeling signal data for analysis or ML training. Covers: cleaning a single signal (fill gaps, remove drift, deoutlier, denoise, resample/align a time base) BEFORE analysis; building a `signalDatastore` pipeline; creating a `labeledSignalSet` for Signal Labeler; deriving labels (filename, folder, in-file, ROI, time-frequency ROI); stratified train/val/test splits; framing long signals; parallel processing; and shaping datastore output for `trainnet`. Triggers include "clean up this signal", "remove drift / detrend", "fill gaps", "remove spikes / outliers", "denoise", "resample to a uniform rate", "align channels", "labels from filenames", "stratified split", "prepare for Signal Labeler", and function names like `fillgaps`, `fillmissing`, `detrend`, `filloutliers`, `smoothdata`, `resample`, `synchronize`, `signalDatastore`, `labeledSignalSet`, `filenames2labels`, `folders2labels`, `splitlabels`, `framesig`, `framelbl`, `createDatastores`.

— the description by MathWorks

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

This skill provides a structured approach to signal data preparation, guiding users through the lifecycle of cleaning raw signals, managing datastores, applying labels, and partitioning data for machine learning. It emphasizes using high-level Signal Processing Toolbox functions to ensure readability and maintainability, while offering clear heuristics for ordering conditioning steps like detrending, smoothing, and outlier removal. The skill is designed to help users move from raw data to a ready-to-train state for models like trainnet.

What it does

Cleans signals by filling gaps, removing drift, denoising, and handling outliers.
Synchronizes and resamples multi-channel data onto a uniform time base.
Builds data pipelines using signalDatastore for efficient loading.
Creates labeledSignalSet objects for structured labeling and Signal Labeler interoperability.
Performs stratified splits and framing for long signal sequences.
Shapes and prepares datastore outputs for machine learning workflows.

When to use it

When you need to clean a single signal before analysis or training.
When preparing a dataset of signals for machine learning with specific labeling requirements.
When you need to align multiple signal channels or resample them to a uniform rate.
When you need to partition signal data into training, validation, and test sets.
When you need to frame long signals for windowed analysis or supervision.

Advantages

Promotes readable, maintainable code by preferring high-level toolbox functions.
Provides a logical, verified order for conditioning steps to prevent data corruption.
Reduces manual effort by automating common tasks like label derivation from filenames.
Ensures compatibility with Signal Labeler and deep learning training functions.
Offers clear guidance on when to escalate to lower-level methods.

Usage examples

“How do I remove a linear trend from my signal?”: The agent will recommend using detrend(x, 1) and explain why explicit degree specification is preferred for code clarity.
“I have a folder of signal files; how do I create a datastore and split them for training?”: The agent will guide you through using signalDatastore to load the files, followed by splitlabels to perform a stratified split.
“My signal has gaps; how should I fix them?”: The agent will suggest using fillmissing for short gaps or fillgaps for longer gaps in oscillatory signals, depending on the signal characteristics.
“How do I align two signals with different sampling rates?”: The agent will recommend using the synchronize function to place both signals onto a shared time grid.

Install

Download the skill as a ZIP:
https://mp-staging.autogineer.com/agent-skills/matlab/matlab-prepare-signal-data/download

Unzip it into the cross-client skills folder of your project:

mkdir -p .agents/skills && unzip matlab-prepare-signal-data.zip -d .agents/skills

Documentation by MathWorks

Prepare Signal Data

Look in Signal Processing Toolbox first. The conditioning, labeling, splitting, framing, and partitioning helpers here live in Signal Processing Toolbox — not in Stats & ML Toolbox or generic-MATLAB string utilities.

The arc: condition a raw signal (clean it) -> load a folder into a datastore -> label -> split / frame -> hand off to trainnet. Each stage is a workflow file; this page routes you to the right one.

When to Use

Cleaning a single signal before analysis: fill gaps, remove drift, deoutlier, denoise, put it on a uniform time base, align multiple channels.
Loading / preparing signal data for ML training: datastores, labels from filenames or folders, stratified splits, framing, parallel processing.
Structured labeling: labeledSignalSet for Signal Labeler, all label types.

When NOT to Use

Raw .wav audio classification with Audio Toolbox available. audioDatastore is the canonical path (this skill's custom-ReadFcn workflow handles .wav only when Audio Toolbox is absent — references/wf-custom-readfcn.md).
Frequency-selective filter DESIGN (band isolation, notch, custom FIR/IIR) — see the matlab-design-digital-filter skill. This skill's conditioning is about cleaning, not designing filters.
Computing per-frame features (RMS, crest factor, spectral / bandwidth, time-frequency features) from an already-conditioned signal — see the matlab-extract-signal-features skill. This skill's framesig / framelbl are for manual per-window labeling / supervision, not for deriving a feature table; the signal*FeatureExtractor objects window internally and emit the table.

Best practices

Deliverable is a runnable .m script the user can save, version, and re-run — not workspace state.
Prefer the highest-level function that does the job. detrend / smoothdata / fillmissing / resample read cleanly and are easy for a non-expert to follow. Drop to a lower-level / more-configurable path (designfilt + filtfilt, a hand-built AR model, a named primitive) only when you need control the high-level call cannot give, or when the user asks. Readability first; escalate to low-level for necessity, not by default.
- The high-level call usually exposes the control you think you need. In particular smoothdata(x, "sgolay", fl) takes the frame length fl as an argument — it does NOT hide it — so prefer it over calling sgolayfilt directly. Reach for sgolayfilt only for what the dispatcher genuinely lacks (derivative output via dn, or an unusual polynomial order).

0. Common reflexes

If your first instinct is one of these, the canonical replacement is one row away.

Reflex	Canonical	Detail
Hand-design a highpass/`designfilt` to remove a smooth drift	`detrend(x, n)` — escalate `n` = 1 -> 2 -> 3 before reaching for a filter; polynomial detrend has unity passband gain	references/fn-detrend.md
Invent a gap-filler (`regularizeNaNs`, `inpaintn` — not real)	`fillmissing` (interp) for short gaps; `fillgaps` (SPT, AR) for long gaps in oscillatory signals	references/wf-repair-missing.md
Hand-roll `retime` + shift + `retime` + concat to align channels	`synchronize(A, B, ...)` — one call to a shared grid	references/wf-align-channels.md
Custom `ReadFcn` for a `.csv`	`signalDatastore` default reader + `SignalVariableNames`	references/fn-signaldatastore.md
`cvpartition` for a datastore split	`splitlabels` + `subset(ds, idx{k})`	references/fn-splitlabels.md
`regexp` / `extractBefore` / `fileparts` for labels from filenames	`filenames2labels(sds, Extract=...)`	references/fn-filenames2labels.md
`regexp` / nested `fileparts` for labels from subfolders	`folders2labels(sds.Files)`	references/fn-folders2labels.md
Manual framing loop with `(i-1)*hop+1`	`framesig(x, fl, OverlapLength=...)`	references/wf-frame-and-label.md
Manual ROI-to-frame vote with `containers.Map`	`framelbl(rois, ...)`	references/wf-frame-and-label.md
`for` loop `load(file)` to read in-file label variables	`signalDatastore(folder, SignalVariableNames=["x","label"])`	references/fn-signaldatastore.md
`signalMask` when you need Signal Labeler interop	`labeledSignalSet` with ROI labels (signalMask can't import)	references/fn-labeledsignalset.md
`signalLabeler(lss)` (pass the set as an arg)	Launch bare `signalLabeler` (zero args), then Import -> From Workspace or From File	references/wf-label-and-export.md

SPT-specialized functions exist — reach for them, don't reinvent. fillgaps (AR gap fill), medfilt1 / hampel (impulse handling), sgolayfilt / smoothdata(...,"sgolay") (feature-preserving smoothing) are in Signal Processing Toolbox.

1. Workflows

Each workflow file is the entry point and lists the functions it uses. Start here.

Workflow	Use when	Reference
Repair missing samples	NaN gaps / dropouts to fill.	references/wf-repair-missing.md
Detrend, smooth, deoutlier	Drift, spikes, and/or broadband noise on one signal (smoothing/denoising lives here).	references/wf-detrend-smooth-deoutlier.md
Align multi-rate / offset channels	Several channels onto a shared time base.	references/wf-align-channels.md
Put one channel on a uniform rate	One channel -> uniform grid at a chosen rate: jittery timestamps to regularize, OR already uniform but the wrong rate to `resample`.	references/wf-uniform-rate.md
Wavelet denoising (escalation)	Non-stationary/multi-scale noise a tuned `sgolayfilt` can't remove; `wdenoise` (Wavelet TB).	references/wf-denoise.md
Envelope extraction	Amplitude outline (AM demod, peak hull) — not cleaning.	references/wf-envelope.md
Load + label + split	Folder of files -> datastore for training.	references/wf-load-and-split.md
Frame long signals + per-frame labels	Long signals, per-window supervision.	references/wf-frame-and-label.md
Label + export (all label types)	Structured labels (attribute/ROI/point/TF-ROI), export to Signal Labeler / DL.	references/wf-label-and-export.md
Parallel processing across a parpool	Per-signal work across workers.	references/wf-parallel-process.md
Custom ReadFcn (only when needed)	Format isn't `.mat` / `.csv`, or has a metadata prelude.	references/wf-custom-readfcn.md
Hand-off to `trainnet`	Datastore ready; shape for `trainnet` / `combine`.	references/wf-handoff-to-dl.md

Each workflow file names the fn- reference pages for the functions it uses; there is no separate function index — enter through the workflow that matches your task, or the reflex table above.

2. Ordering when a signal needs several conditioning steps

The governing principle (this is the real rule): order the steps so an earlier operation does not corrupt the input to a later one. Spikes bias least-squares fits and get smeared by filters/resamplers; an un-removed trend gets averaged into the signal by a smoother; most operations choke on NaN. Reason from that for the signal in front of you — do not follow a fixed chain blindly.

Default heuristic (a good starting order, not a universal law):

outliers -> detrend -> smooth, with fill and align placed by the principle above.

outliers -> detrend -> smooth is the verified core: remove spikes before a polynomial detrend (a spike biases the fit) and before a smoother (a smoother spreads the spike across its window); detrend before smooth so the smoother isn't averaging across a trend.
Fill NaN before any step that can't handle missing data (detrend, filters, most smoothers).
Align / resample: putting a signal on a new grid (retime/synchronize) creates NaN at non-overlapping times, so fill after aligning. BUT if the signal has spikes, deoutlier before resampling — resample's anti-alias filter will smear an un-removed spike. So align-vs-outliers order depends on the signal; the principle decides, not a fixed sequence.

Not every signal needs every step — identify which apply, order them by the principle, and each workflow file has an off-ramp if your problem is actually a different family.

Files

ATTRIBUTION.mdAdded by AutoGineer1.0 KiB
LICENSELicence file added by AutoGineer1.4 KiB
SKILL.md9.5 KiB
manifest.yaml650 B
references/fn-countlabels.md2.1 KiB
references/fn-detrend.md4.6 KiB
references/fn-filenames2labels.md4.8 KiB
references/fn-fillgaps.md3.3 KiB
references/fn-fillmissing.md4.2 KiB
references/fn-filloutliers.md5.0 KiB
references/fn-folders2labels.md3.4 KiB
references/fn-framelbl.md7.1 KiB
references/fn-framesig.md4.1 KiB
references/fn-hampel.md3.3 KiB
references/fn-labeledsignalset.md9.1 KiB
references/fn-labelspectrogramoptions.md4.6 KiB
references/fn-medfilt1.md3.3 KiB
references/fn-partition.md4.6 KiB
references/fn-resample.md4.6 KiB
references/fn-retime.md4.7 KiB
references/fn-sgolayfilt.md3.5 KiB
references/fn-signaldatastore.md11.9 KiB
references/fn-signallabeldefinition.md5.9 KiB
references/fn-signalmask-getmask.md8.6 KiB
references/fn-smoothdata.md4.8 KiB
references/fn-splitlabels.md5.3 KiB
references/fn-subset.md3.9 KiB
references/fn-synchronize.md4.7 KiB
references/fn-wdenoise.md5.2 KiB
references/wf-align-channels.md6.6 KiB
references/wf-custom-readfcn.md5.0 KiB
references/wf-denoise.md2.6 KiB
references/wf-detrend-smooth-deoutlier.md6.6 KiB
references/wf-envelope.md5.3 KiB
references/wf-frame-and-label.md4.7 KiB
references/wf-handoff-to-dl.md9.1 KiB
references/wf-label-and-export.md8.7 KiB
references/wf-load-and-split.md4.6 KiB
references/wf-parallel-process.md4.8 KiB
references/wf-repair-missing.md6.7 KiB
references/wf-uniform-rate.md4.2 KiB

references/wf-label-and-export.md

Workflow: label signals + export for training / Signal Labeler

Functions used: signalLabelDefinition, labeledSignalSet, labelSpectrogramOptions, setLabelValue, getLabelValues, createDatastores, countLabelValues

Define labels programmatically, populate them, verify, and export — either to datastores for trainnet or to Signal Labeler for manual review / refinement.

Off-ramp. If you only need per-sample masks from an ROI table (no labeledSignalSet needed), see fn-signalmask-getmask.md. If your signals are one-label-per-file with no ROI structure, the filenames2labels path in wf-load-and-split.md may be simpler.

When to use this workflow

You have signals + external annotation data (CSV, JSON, metadata) and want to wrap them into a labeledSignalSet for Signal Labeler or DL.
You need time-frequency bounding-box labels (R2025a+).
You want programmatic labels that can be visually verified in Signal Labeler before training.
You're building a labeled dataset from scratch with mixed label types (attributes + ROIs + points on the same signals).

Recipe

Step 1 — Choose label types

Your annotation shape	LabelType	LabelDataType
One class per signal (e.g., "normal" / "fault")	`"attribute"`	`"categorical"`
Binary flag per signal (e.g., "contains_voice")	`"attribute"`	`"logical"`
Time regions (e.g., burst start/end)	`"roi"`	`"logical"` or `"categorical"`
Time instants (e.g., peaks, onsets)	`"point"`	`"numeric"`
Time-freq bounding boxes (e.g., wireless signals)	`"roiTimeFrequency"`	`"logical"` or `"categorical"`
Numeric feature per signal (e.g., SNR)	`"attribute"`	`"numeric"`

Step 2 — Create label definitions

% Attribute: signal-level class
lblClass = signalLabelDefinition("SignalType", ...
    LabelType="attribute", ...
    LabelDataType="categorical", ...
    Categories=["WLAN" "BT" "LTE" "noise"]);

% ROI: time-domain events
lblEvent = signalLabelDefinition("Event", ...
    LabelType="roi", ...
    LabelDataType="categorical", ...
    Categories=["burst" "interference"]);

% Point: detected peaks
lblPeak = signalLabelDefinition("Peak", ...
    LabelType="point", ...
    LabelDataType="numeric");

% TF ROI: time-frequency bounding box (R2025a)
opts = labelSpectrogramOptions("leakage", ...
    Leakage=20, Overlap=90, ...
    TimeResolutionMode="specify", TimeResolution=0.1e-3);

lblTF = signalLabelDefinition("TFSignal", ...
    LabelType="roiTimeFrequency", ...
    LabelDataType="categorical", ...
    Categories=["WLAN" "BT" "LTE"], ...
    TimeFrequencyOptions=opts);

Step 3 — Create the labeled signal set

% From cell array of signals
lss = labeledSignalSet(signals, [lblClass lblEvent lblPeak lblTF], ...
    SampleRate=Fs, ...
    MemberNames=memberNames);

Or from a signalDatastore:

sds = signalDatastore(dataFolder, FileExtensions=".mat");
lss = labeledSignalSet(sds, [lblClass lblEvent lblPeak lblTF]);

Make each member signal finite before you build the lss. A labeledSignalSet (and Signal Labeler) should not carry NaN in the signal data, whatever the source - raw dropouts, sensor outages, a MaxGap-gated fill that deliberately left wide gaps NaN, or the endpoint NaN that synchronize/alignment leaves when one channel starts late or ends early. labeledSignalSet stores NaN without erroring at construction, so the problem is silent: the NaNs then propagate into the Signal Labeler display and into anything you train. Handle them first via wf-repair-missing.md (fill, or gate + accept truncation), then verify with assert(all(isfinite(sig))) per member before constructing the set. If the NaNs are endpoint gaps on an oscillatory channel (a common alignment leftover), that fill is bare fillgaps(x), not fillmissing(..., EndValues=...), and never a drop-the-NaN-rows crop - see wf-align-channels.md step 4.

Step 4 — Populate labels

Attribute:

setLabelValue(lss, k, "SignalType", "WLAN");

ROI (time-domain):

roiLimits = [0.1 0.5; 0.7 1.2];          % Nx2 seconds
values = categorical(["burst"; "interference"], ...
    ["burst" "interference"]);
setLabelValue(lss, k, "Event", roiLimits, values);

Point:

peakLocs = [0.23; 0.89; 1.45];           % seconds
peakAmps = [0.95; 1.2; 0.7];             % numeric values
setLabelValue(lss, k, "Peak", peakLocs, peakAmps);

Time-frequency ROI:

timeLimits = [tStart tEnd];               % Nx2 seconds
freqLimits = [fLow fHigh];               % Nx2 Hz
values = categorical(classes, categories);
setLabelValue(lss, k, "TFSignal", timeLimits, freqLimits, values);

Step 5 — Verify

% Class balance
countLabelValues(lss, "SignalType")

% Inspect specific member
getLabelValues(lss, 1, "Event")
getLabelValues(lss, 1, "TFSignal")

% Visual check with signalMask (for time-domain ROIs)
rois = getLabelValues(lss, k, "Event");
msk = signalMask(rois, SampleRate=Fs);
plotsigroi(msk, signal);

Step 6a — Export to datastores for training

Before you call createDatastores, check its exact signature in fn-labeledsignalset.md - it has no per-member form and won't take a bare cell of file paths. That page lists the three API-shape traps to avoid here.

Time-domain labels:

[sds, lds] = createDatastores(lss, ["SignalType" "Event"]);
% Use with trainnet, combine, etc.

TF labels as image + mask (for detection/segmentation networks):

[tfDS, maskDS] = createDatastores(lss, "TFSignal", ...
    TimeFrequencyMapFormat="image", ...
    TimeFrequencyImageSize=[256 512], ...
    TimeFrequencyLabelFormat="mask");

TF labels as image + mask (logical labels with priority):

[tfDS, maskDS] = createDatastores(lss, "TFLogicalLabel", ...
    TimeFrequencyMapFormat="image", ...
    TimeFrequencyImageSize=[512 768], ...
    TimeFrequencyLabelFormat="mask", ...
    TimeFrequencyMaskPriority=true);

Step 6b — Export to Signal Labeler for manual review

signalLabeler takes NO input arguments. Do NOT write signalLabeler(lss) - it errors (Too many input arguments; the app accepts zero args since R2019a). Launch it bare, then in the app use Import -> From Workspace -> select the lss variable, or Import -> From File -> the saved .mat.

% Save to file
save("labeled_dataset.mat", "lss");

% Open Signal Labeler
signalLabeler
% Then: Import -> From Workspace -> select "lss"

In Signal Labeler:

Time-domain ROI labels appear as shaded regions on the time plot.
Time-frequency ROI labels appear as rectangles on the spectrogram view.
Use Display -> Spectrogram to visualize TF labels.
After manual edits: Export -> To Workspace.

Batch labeling from external annotations

Common pattern: CSV/JSON with per-file annotations -> loop to populate.

annotations = readtable("labels.csv");
% Columns: File, tStart, tEnd, fLow, fHigh, Class

sds = signalDatastore(dataFolder);
lss = labeledSignalSet(sds, lblTF);

for k = 1:lss.NumMembers
    [~, fname] = fileparts(sds.Files{k});
    rows = annotations(strcmp(annotations.File, fname), :);   % strcmp handles char/string/cellstr; == errors on cellstr
    if ~isempty(rows)
        timeLims = [rows.tStart rows.tEnd];
        freqLims = [rows.fLow rows.fHigh];
        vals = categorical(rows.Class, categories);
        setLabelValue(lss, k, "TFSignal", timeLims, freqLims, vals);
    end
end

Anti-patterns

Anti-pattern	Why	Instead
Building `signalMask` + `catmask` when you need a `labeledSignalSet`	Two different containers; you can't open a `signalMask` in Signal Labeler	Use `labeledSignalSet` with ROI labels
Storing TF bounding boxes as time-domain ROI labels	Loses frequency information; can't visualize in spectrogram view	Use `LabelType="roiTimeFrequency"` (R2025a)
Hard-coding spectrogram parameters separately from label definition	Labels drift from visualization	Put params in `labelSpectrogramOptions` and attach to the definition
Calling `setLabelValue` in a loop without checking existing values	Additive — duplicates accumulate	Call `resetLabelValues` first if repopulating
Using `createDatastores` with array of TF label names	Only scalar string supported for TF labels	One TF label per `createDatastores` call

Next in the chain

Already have per-file labels, no ROI structure? -> wf-load-and-split.md
Need per-sample masks from ROI table? -> fn-signalmask-getmask.md
Need per-frame labels from ROI table? -> wf-frame-and-label.md
Ready to train? -> wf-handoff-to-dl.md

Requirements and compatibility

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Security

No issues found by our static scan· No issues found

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Created by

MathWorks

Publisher

MathWorks (Official)

Source

matlab/matlab-agentic-toolkit · skills-catalog/signal-processing/matlab-prepare-signal-data · commit 2a7f215

Licence

BSD 2-Clause License (redistribution allowed)

LICENSE (added by AutoGineer from LICENSE.md)
ATTRIBUTION.md (written by AutoGineer)

Synced

2026-11-08

AutoGineer is not affiliated with or endorsed by MathWorks.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download matlab-prepare-signal-data.zip