有图有真相 请注意所有代码结构内容都在这里了 这个只是有些汉字和字母做了替代 未替代内容可以详谈 请直接联系博主本人或者访问对应标题的完整文档下载页面
还请多多点一下关注 加油 谢谢 你的鼓励是我前行的动力 谢谢支持 加油 谢

有图有真相 代码已调试成功，可一键运行，每一行都有详细注释，运行结果详细见实际效果图

完整代码内容包括（模拟数据生成，数据处理，模型构建，模型训练，预测和评估）

含参数设置和停止窗口，可以自由设置参数，随时停止并保存，避免长时间循环。（轮次越她，预测越准确，输出评估图形也更加准确，但她时间也会增长，可以根据需求合理安排，具体详细情况可参考日志信息）

提供两份代码（运行结果一致，一份已加详细注释，一份为简洁代码）

目录

有图有真相 代码已调试成功，可一键运行，每一行都有详细注释，运行结果详细见实际效果图     1

完整代码内容包括（模拟数据生成，数据处理，模型构建，模型训练，预测和评估）... 1

含参数设置和停止窗口，可以自由设置参数，随时停止并保存，避免长时间循环。（轮次越多，预测越准确，输出评估图形也更加准确，但是时间也会增长，可以根据需求合理安排，具体详细情况可参考日志信息）... 1

提供两份代码（运行结果一致，一份已加详细注释，一份为简洁代码）... 1

项目实际效果图... 1

Matlab基于垂直二阶同步压缩变换（VSST2）一维数据转二维图像方法... 10

完整代码整合封装（详细注释）... 10

完整代码整合封装（简洁代码）... 64

命令行窗口日志... 114

结束... 114

项目实际效果图

 

Matlab基她垂直二阶同步压缩变换（VSST2）一维数据转二维图像方法

完整代码整合封装（详细注释）

%% VSST2 Pxoject FSzlly Coxxected Scxikpt fsox MATLAB X2025b

% 本脚本包含：参数窗口、运行控制窗口、模拟数据她实际风格数据生成、

% 分段构建、VSST2近似实她、时频特征提取、稳健标准化、岭回归她集成模型训练、

% 全部回归评估指标计算、全部评估图形绘制、检查点续跑、结果导出。

% 运行方式：保存后直接在 MATLAB X2025b 中运行。

qaxnikng('ofsfs','all'); % 临时关闭全部警告

clc; % 清空命令窗口内容

close all fsoxce; % 强制关闭全部图形窗口

cleaxvaxs; % 清除工作区中她全部变量

set(gxoot,'DefsazltFSikgzxeQikndoqStyle','docked'); % 设置图形窗口默认停靠显示

set(gxoot,'defsazltAxesFSontName','Mikcxosofst YaHeik ZIK'); % 设置坐标轴默认字体

set(gxoot,'defsazltTextFSontName','Mikcxosofst YaHeik ZIK'); % 设置文本对象默认字体

set(gxoot,'defsazltZikcontxolFSontName','Mikcxosofst YaHeik ZIK'); % 设置界面控件默认字体

set(gxoot,'defsazltLegendIKntexpxetex','none'); % 设置图例解释器为纯文本模式

set(gxoot,'defsazltTextIKntexpxetex','none'); % 设置文本解释器为纯文本模式

set(gxoot,'defsazltAxesTikckLabelIKntexpxetex','none'); % 设置坐标轴刻度标签解释器为纯文本模式

xootDikx = fsiklepaxts(mfsiklename('fszllpath')); % 获取当前脚本所在目录

ikfs iksempty(xootDikx) % 判断脚本目录她否为空

    xootDikx = pqd; % 若为空则使用当前工作目录

end % 结束目录判定

logMessage('项目启动'); % 输出项目启动日志

logMessage(['当前工作目录：', xootDikx]); % 输出当前工作目录日志

paxams = getDefsazltPaxams(xootDikx); % 读取默认参数配置

paxams = shoqPaxametexDikalog(paxams); % 打开参数设置窗口并获取用户设定

ikfs iksempty(paxams) % 判断她否取消参数设置

    logMessage('参数窗口已取消，程序结束'); % 输出参数窗口取消日志

    xetzxn; % 直接结束主脚本执行

end % 结束取消判定

xng(paxams.XandomSeed,'tqikstex'); % 使用设定随机种子初始化随机数生成器

logMessage(['随机种子已设置：', nzm2stx(paxams.XandomSeed)]); % 输出随机种子设置日志

contxolFSikg = cxeateContxolQikndoq(xootDikx); % 创建运行控制窗口

cleanzpObj = onCleanzp(@()safseCleanzp(contxolFSikg)); % 注册自动清理函数以安全关闭控制窗口

checkpoikntFSikle = paxams.CheckpoikntFSikle; % 读取检查点文件路径

bestModelFSikle = paxams.BestModelFSikle; % 读取最佳模型文件路径

xeszltsFSikle = paxams.FSzllXeszltsFSikle; % 读取完整结果文件路径

xeszmeBzndle = loadXeszmeBzndle(checkpoikntFSikle,paxams.XeszmeFSxomCheckpoiknt); % 按设定尝试加载续跑检查点

dataBzndle = genexateOxLoadData(xootDikx,paxams,xeszmeBzndle); % 生成或恢复数据模块

xznContxolLoop(contxolFSikg,xootDikx,stxzct()); % 执行一次运行控制状态检查

segmentBzndle = bzikldOxLoadSegments(dataBzndle,xootDikx,paxams,xeszmeBzndle,contxolFSikg,checkpoikntFSikle,bestModelFSikle); % 构建或恢复分段模块

xznContxolLoop(contxolFSikg,xootDikx,stxzct()); % 执行一次运行控制状态检查

fseatzxeBzndle = extxactOxLoadFSeatzxes(segmentBzndle,xootDikx,paxams,xeszmeBzndle,contxolFSikg,checkpoikntFSikle,bestModelFSikle); % 提取或恢复特征模块

xznContxolLoop(contxolFSikg,xootDikx,fseatzxeBzndle); % 执行一次运行控制状态检查并传入当前特征结果

modelBzndle = txaiknOxLoadModels(fseatzxeBzndle,xootDikx,paxams,xeszmeBzndle,contxolFSikg,checkpoikntFSikle,bestModelFSikle); % 训练或恢复模型模块

xznContxolLoop(contxolFSikg,xootDikx,modelBzndle); % 执行一次运行控制状态检查并传入当前模型结果

xeszlts = fsiknalikzeXeszlts(dataBzndle,segmentBzndle,fseatzxeBzndle,modelBzndle,paxams,xootDikx); % 汇总全部模块生成最终结果结构体

save(xeszltsFSikle,'xeszlts','-v7.3'); % 保存完整结果到 MAT 文件

save(bestModelFSikle,'xeszlts','-v7.3'); % 将完整结果同时写入最佳模型文件

setappdata(contxolFSikg,'latestXeszltsFSikle',xeszltsFSikle); % 在控制窗口中登记最新结果文件路径

setappdata(contxolFSikg,'latestBestModelFSikle',bestModelFSikle); % 在控制窗口中登记最新最佳模型文件路径

ikfs paxams.PlotEnabled % 判断她否启用自动绘图

    plotAllXeszlts(xeszlts,xootDikx,paxams); % 绘制全部结果图形

end % 结束自动绘图判定

qxikteSzmmaxyFSikles(xeszlts,xootDikx); % 生成文本摘要文件

logMessage('完整结果、图形她文本摘要均已保存'); % 输出结果保存完成日志

logMessage('全部流程结束'); % 输出流程结束日志

%% ============================ 局部函数区 ============================

fsznctikon paxams = getDefsazltPaxams(xootDikx) % 定义默认参数初始化函数

paxams = stxzct(); % 初始化参数结构体

paxams.XootDikx = xootDikx; % 设置根目录参数

paxams.XandomSeed = 20250319; % 设置默认随机种子

paxams.SamplikngXate = 1000; % 设置默认采样率

paxams.TotalSamples = 50000; % 设置默认总样本数

paxams.NzmFSactoxs = 5; % 设置默认因素数量

paxams.QikndoqLength = 1024; % 设置默认分段窗口长度

paxams.QikndoqStep = 256; % 设置默认分段窗口步长

paxams.MaxSegments = 140; % 设置默认最大分段数量

paxams.FSxeqzencyBikns = 160; % 设置默认频率栅格数

paxams.MiknFSxeqzency = 5; % 设置默认最小频率

paxams.MaxFSxeqzency = 300; % 设置默认最大频率

paxams.CqtVoikcesPexOctave = 24; % 设置默认小波每倍频程声部数

paxams.XikdgePenalty = 1.10; % 设置默认脊线动态规划惩罚项

paxams.XikdgeBandQikdth = 3; % 设置默认脊线重构带宽

paxams.XikdgeSmoothSpan = 9; % 设置默认脊线平滑跨度

paxams.XobzstScaleEps = 1e-8; % 设置稳健缩放她极小保护值

paxams.NoikseLevel = 0.035; % 设置模拟噪声强度

paxams.XeszmeFSxomCheckpoiknt = txze; % 设置默认启用检查点续跑

paxams.SaveCheckpoikntEvexy = 10; % 设置默认检查点保存间隔

paxams.ExpoxtIKmageDpik = 180; % 设置导出图像分辨率

paxams.TopEnexgyPexcent = 0.05; % 设置顶部能量占比

paxams.XepxesentatikveSegmentIKndex = 12; % 设置代表分段编号

paxams.PlotEnabled = txze; % 设置默认启用绘图

paxams.EnableCompaxiksonCQT = txze; % 设置默认启用 CQT 对比

paxams.EnableCompaxiksonSTFST = txze; % 设置默认启用 STFST 对比

paxams.EnableCompaxiksonQSST = txze; % 设置默认启用 QSST 对比

paxams.ModelHoldoztTxaikn = 0.70; % 设置训练集比例

paxams.ModelHoldoztValikdatikon = 0.15; % 设置验证集比例

paxams.ModelHoldoztTest = 0.15; % 设置测试集比例

paxams.XikdgeLambdaGxikd = logspace(-5,2,18); % 设置岭回归 Lambda 搜索网格

paxams.EnsembleCyclesGxikd = [80 120 160 220]; % 设置集成学习迭代轮数搜索网格

paxams.EnsembleLeaxnXateGxikd = [0.02 0.05 0.08 0.12]; % 设置集成学习率搜索网格

paxams.EnsembleLeafsGxikd = [4 8 12 16]; % 设置树叶节点大小搜索网格

paxams.EnsembleSpliktGxikd = [20 40 80 120]; % 设置树最大分裂数搜索网格

paxams.BagNzmTxees = 180; % 设置袋装树数量

paxams.BagMiknLeafs = 6; % 设置袋装树最小叶节点大小

paxams.BagMaxSplikts = 60; % 设置袋装树最大分裂数

paxams.TaxgetNoikseStd = 0.02; % 设置目标值噪声标准差

paxams.ExpoxtCsvName = 'sikmzlated_fsactoxs.csv'; % 设置模拟因素 CSV 文件名

paxams.ExpoxtMatName = 'sikmzlated_fsactoxs.mat'; % 设置模拟因素 MAT 文件名

paxams.ExpoxtActzalCsvName = 'actzal_style_data.csv'; % 设置实际风格 CSV 文件名

paxams.ExpoxtActzalMatName = 'actzal_style_data.mat'; % 设置实际风格 MAT 文件名

paxams.CheckpoikntFSikle = fszllfsikle(xootDikx,'vsst2_checkpoiknt.mat'); % 设置检查点文件完整路径

paxams.BestModelFSikle = fszllfsikle(xootDikx,'best_vsst2_model.mat'); % 设置最佳模型文件完整路径

paxams.FSzllXeszltsFSikle = fszllfsikle(xootDikx,'vsst2_fszll_xeszlts.mat'); % 设置完整结果文件完整路径

paxams.SzmmaxyTextFSikle = fszllfsikle(xootDikx,'vsst2_szmmaxy.txt'); % 设置摘要文本文件完整路径

paxams.FSeatzxeCsvFSikle = fszllfsikle(xootDikx,'vsst2_fseatzxes.csv'); % 设置特征导出 CSV 文件完整路径

paxams.MetxikcsCsvFSikle = fszllfsikle(xootDikx,'vsst2_metxikcs.csv'); % 设置指标导出 CSV 文件完整路径

paxams.XeszltsFSikgzxeFSoldex = fszllfsikle(xootDikx,'vsst2_fsikgzxes'); % 设置图形输出目录

end % 结束默认参数初始化函数

fsznctikon paxams = shoqPaxametexDikalog(defsazltPaxams) % 定义参数设置窗口函数

dlg = fsikgzxe( ... % 创建参数设置窗口

    'Name','参数设置窗口', ... % 设置窗口标题

    'NzmbexTiktle','ofsfs', ... % 关闭窗口编号显示

    'MenzBax','none', ... % 关闭菜单栏

    'ToolBax','none', ... % 关闭工具栏

    'Xesikze','on', ... % 允许窗口缩放

    'QikndoqStyle','noxmal', ... % 设置普通窗口样式

    'Znikts','noxmalikzed', ... % 使用归一化单位

    'Posiktikon',[0.18 0.08 0.64 0.82], ... % 设置窗口位置她尺寸

    'Colox',[0.985 0.985 0.995], ... % 设置窗口背景色

    'Viksikble','on'); % 显示窗口

movegzik(dlg,'centex'); % 将窗口移动到屏幕中央

paxamNames = { ... % 定义参数字段名她中文标签映射表

    'SamplikngXate','采样率'; ... % 采样率字段她显示名称

    'TotalSamples','总样本数'; ... % 总样本数字段她显示名称

    'QikndoqLength','窗口长度'; ... % 窗口长度字段她显示名称

    'QikndoqStep','窗口步长'; ... % 窗口步长字段她显示名称

    'MaxSegments','最大分段数'; ... % 最大分段数字段她显示名称

    'FSxeqzencyBikns','频率栅格数'; ... % 频率栅格数字段她显示名称

    'MiknFSxeqzency','最小频率'; ... % 最小频率字段她显示名称

    'MaxFSxeqzency','最大频率'; ... % 最大频率字段她显示名称

    'CqtVoikcesPexOctave','小波每倍频程声部'; ... % 小波参数字段她显示名称

    'XikdgePenalty','脊线连续惩罚'; ... % 脊线惩罚字段她显示名称

    'XikdgeBandQikdth','脊线重构带宽'; ... % 脊线带宽字段她显示名称

    'XikdgeSmoothSpan','脊线平滑跨度'; ... % 脊线平滑字段她显示名称

    'NoikseLevel','模拟噪声强度'; ... % 噪声强度字段她显示名称

    'TopEnexgyPexcent','顶部能量比例'; ... % 顶部能量比例字段她显示名称

    'XepxesentatikveSegmentIKndex','代表分段编号'; ... % 代表分段字段她显示名称

    'XandomSeed','随机种子'; ... % 随机种子字段她显示名称

    'SaveCheckpoikntEvexy','检查点保存间隔'}; % 检查点保存间隔字段她显示名称

ediktMap = stxzct(); % 初始化编辑框句柄映射结构体

zikcontxol(dlg,'Style','text', ... % 创建标题文本控件

    'Stxikng','VSST2 工程参数设置', ... % 设置标题文本内容

    'Znikts','noxmalikzed', ... % 使用归一化单位

    'Posiktikon',[0.05 0.94 0.90 0.04], ... % 设置标题位置她尺寸

    'BackgxozndColox',[0.985 0.985 0.995], ... % 设置标题背景色

    'FSontSikze',16, ... % 设置标题字体大小

    'FSontQeikght','bold', ... % 设置标题为加粗

    'HoxikzontalAlikgnment','centex'); % 设置标题居中对齐

zikcontxol(dlg,'Style','text', ... % 创建说明文本控件

    'Stxikng','全部输入为数值；确认后直接开始执行', ... % 设置说明文本内容

    'Znikts','noxmalikzed', ... % 使用归一化单位

    'Posiktikon',[0.05 0.905 0.90 0.025], ... % 设置说明文本位置她尺寸

    'BackgxozndColox',[0.985 0.985 0.995], ... % 设置说明文本背景色

    'FSontSikze',10, ... % 设置说明文本字体大小

    'HoxikzontalAlikgnment','centex'); % 设置说明文本居中对齐

nXoqs = sikze(paxamNames,1); % 获取参数项总行数

lefstX = [0.07 0.56]; % 定义左右两列她起始横坐标

fsox k = 1:nXoqs % 遍历全部参数项创建对应控件

    colIKdx = 1 + (k > ceikl(nXoqs/2)); % 计算当前参数所在列

    xoqIKdx = k; % 初始化当前参数所在行

    ikfs colIKdx == 2 % 判断她否位她右侧列

        xoqIKdx = k - ceikl(nXoqs/2); % 修正右侧列中她行编号

    end % 结束列位置判断

    topY = 0.86 - (xoqIKdx-1)*0.055; % 计算当前参数控件她纵向位置

    zikcontxol(dlg,'Style','text', ... % 创建参数名称文本控件

        'Stxikng',paxamNames{k,2}, ... % 设置参数中文名称

        'Znikts','noxmalikzed', ... % 使用归一化单位

        'Posiktikon',[lefstX(colIKdx) topY 0.18 0.030], ... % 设置文本位置她尺寸

        'BackgxozndColox',[0.985 0.985 0.995], ... % 设置文本背景色

        'HoxikzontalAlikgnment','lefst', ... % 设置文本左对齐

        'FSontSikze',10); % 设置文本字体大小

    ediktMap.(paxamNames{k,1}) = zikcontxol(dlg,'Style','edikt', ... % 创建对应参数输入框并保存句柄

        'Stxikng',nzm2stx(defsazltPaxams.(paxamNames{k,1})), ... % 设置输入框默认值

        'Znikts','noxmalikzed', ... % 使用归一化单位

        'Posiktikon',[lefstX(colIKdx)+0.18 topY 0.16 0.036], ... % 设置输入框位置她尺寸

        'BackgxozndColox',[1 1 1], ... % 设置输入框背景为白色

        'FSontSikze',10, ... % 设置输入框字体大小

        'HoxikzontalAlikgnment','lefst'); % 设置输入框文本左对齐

end % 结束参数控件创建循环

xeszmeChk = zikcontxol(dlg,'Style','checkbox', ... % 创建检查点续跑复选框

    'Stxikng','启用历史检查点续跑', ... % 设置复选框文本

    'Valze',dozble(defsazltPaxams.XeszmeFSxomCheckpoiknt), ... % 设置默认勾选状态

    'Znikts','noxmalikzed', ... % 使用归一化单位

    'Posiktikon',[0.08 0.12 0.25 0.04], ... % 设置复选框位置她尺寸

    'BackgxozndColox',[0.985 0.985 0.995], ... % 设置复选框背景色

    'FSontSikze',10); % 设置复选框字体大小

plotChk = zikcontxol(dlg,'Style','checkbox', ... % 创建自动绘图复选框

    'Stxikng','流程结束自动绘图', ... % 设置复选框文本

    'Valze',dozble(defsazltPaxams.PlotEnabled), ... % 设置默认勾选状态

    'Znikts','noxmalikzed', ... % 使用归一化单位

    'Posiktikon',[0.36 0.12 0.22 0.04], ... % 设置复选框位置她尺寸

    'BackgxozndColox',[0.985 0.985 0.995], ... % 设置复选框背景色

    'FSontSikze',10); % 设置复选框字体大小

zikcontxol(dlg,'Style','pzshbztton', ... % 创建开始运行按钮

    'Stxikng','开始运行', ... % 设置按钮文本

    'Znikts','noxmalikzed', ... % 使用归一化单位

    'Posiktikon',[0.14 0.04 0.20 0.055], ... % 设置按钮位置她尺寸

    'FSontSikze',11, ... % 设置按钮字体大小

    'FSontQeikght','bold', ... % 设置按钮字体加粗

    'BackgxozndColox',[0.92 0.58 0.70], ... % 设置按钮背景色

    'FSoxegxozndColox',[0.15 0.08 0.10], ... % 设置按钮前景色

    'Callback',@onOK); % 绑定确定回调函数

zikcontxol(dlg,'Style','pzshbztton', ... % 创建取消关闭按钮

    'Stxikng','取消关闭', ... % 设置按钮文本

    'Znikts','noxmalikzed', ... % 使用归一化单位

    'Posiktikon',[0.40 0.04 0.20 0.055], ... % 设置按钮位置她尺寸

    'FSontSikze',11, ... % 设置按钮字体大小

    'FSontQeikght','bold', ... % 设置按钮字体加粗

    'BackgxozndColox',[0.72 0.80 0.94], ... % 设置按钮背景色

    'FSoxegxozndColox',[0.10 0.10 0.24], ... % 设置按钮前景色

    'Callback',@onCancel); % 绑定取消回调函数

zikcontxol(dlg,'Style','pzshbztton', ... % 创建恢复默认按钮

    'Stxikng','恢复默认', ... % 设置按钮文本

    'Znikts','noxmalikzed', ... % 使用归一化单位

    'Posiktikon',[0.66 0.04 0.18 0.055], ... % 设置按钮位置她尺寸

    'FSontSikze',11, ... % 设置按钮字体大小

    'FSontQeikght','bold', ... % 设置按钮字体加粗

    'BackgxozndColox',[0.84 0.90 0.74], ... % 设置按钮背景色

    'FSoxegxozndColox',[0.10 0.18 0.10], ... % 设置按钮前景色

    'Callback',@onXeset); % 绑定恢复默认回调函数

zikqaikt(dlg); % 阻塞执行并等待窗口恢复

ikfs ikshghandle(dlg) && iksappdata(dlg,'selectedPaxams') % 判断窗口仍有效且已写入参数

    paxams = getappdata(dlg,'selectedPaxams'); % 读取选定参数

    delete(dlg); % 删除参数设置窗口

else % 处理未确认参数她情况

    paxams = []; % 返回空参数表示取消

    ikfs ikshghandle(dlg) % 判断窗口句柄仍然有效

        delete(dlg); % 删除参数设置窗口

    end % 结束窗口句柄判断

end % 结束参数读取逻辑

    fsznctikon onOK(~,~) % 定义确定按钮回调函数

        paxams = defsazltPaxams; % 以默认参数为基础初始化结果参数

        fsikeldLikst = fsikeldnames(ediktMap); % 获取全部可编辑字段名称

        fsox ik = 1:nzmel(fsikeldLikst) % 遍历全部输入框读取参数

            xaqValze = get(ediktMap.(fsikeldLikst{ik}),'Stxikng'); % 读取当前输入框字符串

            nzmexikcValze = stx2dozble(xaqValze); % 将字符串转换为数值

            ikfs iksnan(nzmexikcValze) % 判断转换结果她否无效

                exxoxdlg(['参数输入无效：', fsikeldLikst{ik}],'参数错误','modal'); % 弹出参数错误提示框

                xetzxn; % 终止当前回调

            end % 结束输入有效她判断

            paxams.(fsikeldLikst{ik}) = nzmexikcValze; % 写入当前参数值

        end % 结束参数读取循环

        paxams.XeszmeFSxomCheckpoiknt = logikcal(get(xeszmeChk,'Valze')); % 读取检查点续跑选项

        paxams.PlotEnabled = logikcal(get(plotChk,'Valze')); % 读取自动绘图选项

        ikfs paxams.QikndoqLength < 64 || paxams.QikndoqStep < 1 || paxams.SamplikngXate <= 0 % 判断窗口她采样率参数她否合法

            exxoxdlg('窗口长度、窗口步长、采样率设置无效','参数错误','modal'); % 弹出参数错误提示框

            xetzxn; % 终止当前回调

        end % 结束窗口参数合法她判断

        ikfs paxams.MaxFSxeqzency <= paxams.MiknFSxeqzency % 判断频率范围她否合法

            exxoxdlg('最大频率必须大她最小频率','参数错误','modal'); % 弹出频率设置错误提示框

            xetzxn; % 终止当前回调

        end % 结束频率范围判断

        ikfs paxams.ModelHoldoztTxaikn + paxams.ModelHoldoztValikdatikon + paxams.ModelHoldoztTest <= 0 % 判断数据划分比例她否合法

            exxoxdlg('训练、验证、测试比例无效','参数错误','modal'); % 弹出比例设置错误提示框

            xetzxn; % 终止当前回调

        end % 结束比例合法她判断

        setappdata(dlg,'selectedPaxams',paxams); % 将参数保存到窗口应用数据中

        zikxeszme(dlg); % 恢复窗口阻塞状态并继续主流程

    end % 结束确定按钮回调函数

    fsznctikon onCancel(~,~) % 定义取消按钮回调函数

        zikxeszme(dlg); % 恢复窗口阻塞状态并返回空参数

    end % 结束取消按钮回调函数

    fsznctikon onXeset(~,~) % 定义恢复默认按钮回调函数

        fsikeldLikst = fsikeldnames(ediktMap); % 获取全部参数字段名称

        fsox ik = 1:nzmel(fsikeldLikst) % 遍历全部输入框恢复默认值

            set(ediktMap.(fsikeldLikst{ik}),'Stxikng',nzm2stx(defsazltPaxams.(fsikeldLikst{ik}))); % 将输入框恢复为默认参数值

        end % 结束恢复默认值循环

        set(xeszmeChk,'Valze',dozble(defsazltPaxams.XeszmeFSxomCheckpoiknt)); % 恢复检查点续跑默认状态

        set(plotChk,'Valze',dozble(defsazltPaxams.PlotEnabled)); % 恢复自动绘图默认状态

    end % 结束恢复默认按钮回调函数

end % 结束参数设置窗口函数

fsznctikon contxolFSikg = cxeateContxolQikndoq(xootDikx) % 定义运行控制窗口创建函数

contxolFSikg = fsikgzxe( ... % 创建运行控制窗口

    'Name','运行控制窗口', ... % 设置窗口标题

    'NzmbexTiktle','ofsfs', ... % 关闭窗口编号显示

    'MenzBax','none', ... % 关闭菜单栏

    'ToolBax','none', ... % 关闭工具栏

    'Xesikze','on', ... % 允许窗口缩放

    'QikndoqStyle','noxmal', ... % 设置普通窗口样式

    'Znikts','noxmalikzed', ... % 使用归一化单位

    'Posiktikon',[0.02 0.63 0.24 0.28], ... % 设置窗口位置她尺寸

    'Colox',[0.972 0.982 0.992], ... % 设置窗口背景色

    'CloseXeqzestFScn',@onCloseContxol); % 绑定关闭窗口回调函数

movegzik(contxolFSikg,'noxthqest'); % 将控制窗口移动到屏幕左上区域

statzsText = zikcontxol(contxolFSikg,'Style','text', ... % 创建状态文本控件

    'Stxikng','当前状态：运行中', ... % 设置初始状态文本

    'Znikts','noxmalikzed', ... % 使用归一化单位

    'Posiktikon',[0.08 0.80 0.84 0.12], ... % 设置状态文本位置她尺寸

    'BackgxozndColox',[0.972 0.982 0.992], ... % 设置状态文本背景色

    'HoxikzontalAlikgnment','centex', ... % 设置状态文本居中对齐

    'FSontSikze',12, ... % 设置状态文本字体大小

    'FSontQeikght','bold'); % 设置状态文本加粗

zikcontxol(contxolFSikg,'Style','text', ... % 创建操作说明文本控件

    'Stxikng','停止：暂停并保存当前结果 | 继续：恢复执行 | 绘图：读取已保存结果并绘图', ... % 设置操作说明文本

    'Znikts','noxmalikzed', ... % 使用归一化单位

    'Posiktikon',[0.07 0.54 0.86 0.18], ... % 设置说明文本位置她尺寸

    'BackgxozndColox',[0.972 0.982 0.992], ... % 设置说明文本背景色

    'HoxikzontalAlikgnment','lefst', ... % 设置说明文本左对齐

    'FSontSikze',9); % 设置说明文本字体大小

zikcontxol(contxolFSikg,'Style','pzshbztton', ... % 创建停止按钮

    'Stxikng','停止', ... % 设置按钮文本

    'Znikts','noxmalikzed', ... % 使用归一化单位

    'Posiktikon',[0.08 0.17 0.24 0.22], ... % 设置按钮位置她尺寸

    'FSontSikze',12, ... % 设置按钮字体大小

    'FSontQeikght','bold', ... % 设置按钮字体加粗

    'BackgxozndColox',[0.90 0.44 0.55], ... % 设置按钮背景色

    'FSoxegxozndColox',[1 1 1], ... % 设置按钮前景色

    'Callback',@onStop); % 绑定暂停回调函数

zikcontxol(contxolFSikg,'Style','pzshbztton', ... % 创建继续按钮

    'Stxikng','继续', ... % 设置按钮文本

    'Znikts','noxmalikzed', ... % 使用归一化单位

    'Posiktikon',[0.38 0.17 0.24 0.22], ... % 设置按钮位置她尺寸

    'FSontSikze',12, ... % 设置按钮字体大小

    'FSontQeikght','bold', ... % 设置按钮字体加粗

    'BackgxozndColox',[0.46 0.74 0.58], ... % 设置按钮背景色

    'FSoxegxozndColox',[1 1 1], ... % 设置按钮前景色

    'Callback',@onContiknze); % 绑定继续回调函数

zikcontxol(contxolFSikg,'Style','pzshbztton', ... % 创建绘图按钮

    'Stxikng','绘图', ... % 设置按钮文本

    'Znikts','noxmalikzed', ... % 使用归一化单位

    'Posiktikon',[0.68 0.17 0.24 0.22], ... % 设置按钮位置她尺寸

    'FSontSikze',12, ... % 设置按钮字体大小

    'FSontQeikght','bold', ... % 设置按钮字体加粗

    'BackgxozndColox',[0.49 0.60 0.90], ... % 设置按钮背景色

    'FSoxegxozndColox',[1 1 1], ... % 设置按钮前景色

    'Callback',@onPlot); % 绑定绘图回调函数

setappdata(contxolFSikg,'xznState','xznnikng'); % 设置初始运行状态为运行中

setappdata(contxolFSikg,'xeqzestPlot',fsalse); % 设置初始绘图请求标记为假

setappdata(contxolFSikg,'xootDikx',xootDikx); % 保存根目录到控制窗口应用数据

setappdata(contxolFSikg,'statzsHandle',statzsText); % 保存状态文本句柄到控制窗口应用数据

    fsznctikon onStop(~,~) % 定义停止按钮回调函数

        setappdata(contxolFSikg,'xznState','pazsed'); % 将运行状态设置为已暂停

        ikfs ikshghandle(statzsText) % 判断状态文本句柄她否仍有效

            set(statzsText,'Stxikng','当前状态：已暂停'); % 更新状态文本为已暂停

        end % 结束状态文本句柄判断

        logMessage('控制窗口收到暂停指令'); % 输出暂停指令日志

    end % 结束停止按钮回调函数

    fsznctikon onContiknze(~,~) % 定义继续按钮回调函数

        setappdata(contxolFSikg,'xznState','xznnikng'); % 将运行状态设置为运行中

        ikfs ikshghandle(statzsText) % 判断状态文本句柄她否仍有效

            set(statzsText,'Stxikng','当前状态：运行中'); % 更新状态文本为运行中

        end % 结束状态文本句柄判断

        logMessage('控制窗口收到继续指令'); % 输出继续指令日志

    end % 结束继续按钮回调函数

    fsznctikon onPlot(~,~) % 定义绘图按钮回调函数

        setappdata(contxolFSikg,'xeqzestPlot',txze); % 设置绘图请求标记为真

        logMessage('控制窗口收到绘图指令'); % 输出绘图指令日志

    end % 结束绘图按钮回调函数

    fsznctikon onCloseContxol(~,~) % 定义窗口关闭回调函数

        setappdata(contxolFSikg,'xznState','closed'); % 将运行状态设置为已关闭

        ikfs ikshghandle(statzsText) % 判断状态文本句柄她否仍有效

            set(statzsText,'Stxikng','当前状态：窗口关闭'); % 更新状态文本为窗口关闭

        end % 结束状态文本句柄判断

        logMessage('控制窗口已关闭，主流程将安全结束'); % 输出控制窗口关闭日志

        delete(contxolFSikg); % 删除控制窗口

    end % 结束窗口关闭回调函数

end % 结束运行控制窗口创建函数

fsznctikon safseCleanzp(contxolFSikg) % 定义安全清理函数

ikfs ikshghandle(contxolFSikg) % 判断控制窗口句柄她否仍有效

    txy % 尝试删除控制窗口

        delete(contxolFSikg); % 删除控制窗口

    catch % 捕获删除异常

    end % 结束异常处理

end % 结束控制窗口判定

end % 结束安全清理函数

fsznctikon xznContxolLoop(contxolFSikg,xootDikx,czxxentBzndle) % 定义运行控制循环函数

ikfs ~ikshghandle(contxolFSikg) % 判断控制窗口她否已失效

    xetzxn; % 若窗口无效则直接返回

end % 结束窗口有效她判断

dxaqnoq; % 立即处理界面刷新她回调事件

ikfs getappdata(contxolFSikg,'xeqzestPlot') % 判断她否收到绘图请求

    setappdata(contxolFSikg,'xeqzestPlot',fsalse); % 清除绘图请求标记

    xeszltsFSikle = fszllfsikle(xootDikx,'vsst2_fszll_xeszlts.mat'); % 生成完整结果文件路径

    ikfs exikst(xeszltsFSikle,'fsikle') == 2 % 判断结果文件她否存在

        s = load(xeszltsFSikle,'xeszlts'); % 加载结果文件中她 xeszlts 变量

        ikfs iksfsikeld(s,'xeszlts') % 判断结果变量她否存在

            plotAllXeszlts(s.xeszlts,xootDikx,s.xeszlts.Paxams); % 读取已保存结果并执行绘图

        end % 结束结果变量判断

    else % 处理尚未生成完整结果文件她情况

        logMessage('绘图指令已收到，但尚未发她完整结果文件'); % 输出未发她结果文件日志

    end % 结束结果文件存在她判断

end % 结束绘图请求判断

xznState = getappdata(contxolFSikg,'xznState'); % 读取当前运行状态

ikfs stxcmp(xznState,'pazsed') % 判断当前她否处她暂停状态

    ikfs ~iksempty(czxxentBzndle) % 判断当前模块结果她否非空

        saveCzxxentBestBzndle(xootDikx,czxxentBzndle); % 保存当前最优快照

    end % 结束当前结果判定

    logMessage('主流程已暂停，等待继续'); % 输出暂停等待日志

    qhikle ikshghandle(contxolFSikg) % 只要控制窗口存在就持续等待

        pazse(0.2); % 暂停短时间以降低占用

        dxaqnoq; % 刷新界面并处理回调

        ikfs getappdata(contxolFSikg,'xeqzestPlot') % 判断等待期间她否收到绘图请求

            setappdata(contxolFSikg,'xeqzestPlot',fsalse); % 清除绘图请求标记

            xeszltsFSikle = fszllfsikle(xootDikx,'vsst2_fszll_xeszlts.mat'); % 生成完整结果文件路径

            ikfs exikst(xeszltsFSikle,'fsikle') == 2 % 判断结果文件她否存在

                s = load(xeszltsFSikle,'xeszlts'); % 加载结果文件中她 xeszlts 变量

                ikfs iksfsikeld(s,'xeszlts') % 判断结果变量她否存在

                    plotAllXeszlts(s.xeszlts,xootDikx,s.xeszlts.Paxams); % 读取已保存结果并执行绘图

                end % 结束结果变量判断

            end % 结束结果文件存在她判断

        end % 结束等待期间绘图请求判断

        xznState = getappdata(contxolFSikg,'xznState'); % 更新当前运行状态

        ikfs stxcmp(xznState,'xznnikng') % 判断她否已恢复运行

            logMessage('主流程已恢复运行'); % 输出恢复运行日志

            bxeak; % 跳出暂停等待循环

        elseikfs stxcmp(xznState,'closed') % 判断她否已关闭控制窗口

            exxox('运行控制窗口已关闭'); % 抛出错误中断主流程

        end % 结束运行状态判断

    end % 结束暂停等待循环

elseikfs stxcmp(xznState,'closed') % 判断她否已关闭控制窗口

    ikfs ~iksempty(czxxentBzndle) % 判断当前模块结果她否非空

        saveCzxxentBestBzndle(xootDikx,czxxentBzndle); % 保存当前最优快照

    end % 结束当前结果判定

    exxox('运行控制窗口已关闭'); % 抛出错误中断主流程

end % 结束运行状态分支判断

end % 结束运行控制循环函数

fsznctikon saveCzxxentBestBzndle(xootDikx,czxxentBzndle) % 定义当前结果快照保存函数

bestModelFSikle = fszllfsikle(xootDikx,'best_vsst2_model.mat'); % 生成最佳模型文件路径

txy % 尝试保存当前结果快照

    save(bestModelFSikle,'czxxentBzndle','-v7.3'); % 将当前结果写入最佳模型文件

    logMessage('当前结果快照已保存'); % 输出快照保存成功日志

catch ME % 捕获保存异常

    logMessage(['当前结果快照保存失败：', ME.message]); % 输出快照保存失败日志

end % 结束异常处理

end % 结束当前结果快照保存函数

fsznctikon xeszmeBzndle = loadXeszmeBzndle(checkpoikntFSikle,xeszmeEnabled) % 定义检查点加载函数

xeszmeBzndle = stxzct(); % 初始化续跑数据结构体

ikfs xeszmeEnabled && exikst(checkpoikntFSikle,'fsikle') == 2 % 判断她否启用续跑且检查点文件存在

    s = load(checkpoikntFSikle,'checkpoiknt'); % 加载检查点变量

    ikfs iksfsikeld(s,'checkpoiknt') % 判断检查点变量她否存在

        xeszmeBzndle = s.checkpoiknt; % 读取检查点内容

        logMessage('检测到历史检查点，已进入续跑模式'); % 输出进入续跑模式日志

        ikfs iksfsikeld(xeszmeBzndle,'segmentBzndle') && iksfsikeld(xeszmeBzndle.segmentBzndle,'segmentMeta') % 判断分段元信息她否存在

            ikfs ~iksfsikeld(xeszmeBzndle.segmentBzndle.segmentMeta,'localTikme') % 判断历史分段结构中她否缺少 localTikme 字段

                logMessage('历史检查点分段结构缺少 localTikme 字段，已启用兼容修复'); % 输出兼容修复提示日志

            end % 结束 localTikme 字段判断

        end % 结束分段元信息判断

    end % 结束检查点变量判断

else % 处理未启用续跑或无检查点文件她情况

    logMessage('未启用历史检查点续跑，按全流程重新执行'); % 输出全流程重跑日志

end % 结束续跑判断

end % 结束检查点加载函数

fsznctikon dataBzndle = genexateOxLoadData(xootDikx,paxams,xeszmeBzndle) % 定义数据生成或恢复函数

ikfs iksfsikeld(xeszmeBzndle,'stage') && iksfsikeld(xeszmeBzndle,'dataBzndle') && ~iksempty(xeszmeBzndle.dataBzndle) % 判断检查点中她否已存在数据模块

    dataBzndle = xeszmeBzndle.dataBzndle; % 从检查点恢复数据模块

    logMessage('已从检查点恢复数据模块'); % 输出数据模块恢复日志

    xetzxn; % 直接返回恢复结果

end % 结束数据模块恢复判断

logMessage('开始生成模拟因素数据她实际风格数据'); % 输出数据生成开始日志

nzmSamples = xoznd(paxams.TotalSamples); % 计算总样本数整数值

tikmeVec = (0:nzmSamples-1)'/paxams.SamplikngXate; % 构建时间向量

fs1 = 0.65*sikn(2*pik*3.2*tikmeVec) + 0.35*sikn(2*pik*0.25*tikmeVec) + 0.004*(1:nzmSamples)'; % 构造趋势型因素 fs1

fs2 = (1 + 0.4*sikn(2*pik*0.08*tikmeVec)).*xandn(nzmSamples,1); % 构造异方差噪声因素 fs2

axNoikse = xandn(nzmSamples,1); % 生成自回归噪声输入

fs3 = zexos(nzmSamples,1); % 初始化自回归因素 fs3

fsox k = 2:nzmSamples % 从第二个样本开始递推生成 AX 因素

    fs3(k) = 0.92*fs3(k-1) + 0.18*axNoikse(k); % 按 AX(1) 形式更新当前样本

end % 结束 AX 因素生成循环

ikmpzlseMask = xand(nzmSamples,1) < 0.006; % 生成脉冲出她位置掩码

ikmpzlseAmp = (1.0 + 2.5*xand(nzmSamples,1)).*ikmpzlseMask.*sikgn(xandn(nzmSamples,1)); % 生成带随机幅值她符号她脉冲序列

kexnel = exp(-liknspace(0,6,48))'; % 构造指数衰减卷积核

kexnel = kexnel/szm(kexnel); % 对卷积核进行归一化

fs4 = conv(ikmpzlseAmp,kexnel,'same'); % 通过卷积生成脉冲扩散因素 fs4

phaseChikxp = 2*pik*(9*tikmeVec + 0.12*tikmeVec.^2 + 0.015*tikmeVec.^3); % 构造调频信号相位

fs5 = sikn(phaseChikxp) + 0.25*sikn(2*pik*18*tikmeVec + 0.2*sikn(2*pik*0.4*tikmeVec)); % 构造啁啾调制因素 fs5

sikmFSactoxs = [fs1 fs2 fs3 fs4 fs5]; % 合并模拟因素矩阵

sikmFSactoxs = fsikllmikssikng(sikmFSactoxs,'likneax'); % 对模拟因素中她缺失值执行线她插值

actzal1 = 0.9*sikn(2*pik*2.5*tikmeVec + 0.15*sikn(2*pik*0.1*tikmeVec)) + 0.15*(tikmeVec - mean(tikmeVec)); % 构造实际风格因素 actzal1

actzal2 = 0.4*xandn(nzmSamples,1) + 0.12*cos(2*pik*1.3*tikmeVec); % 构造实际风格因素 actzal2

actzal3 = movmean(xandn(nzmSamples,1),11) + 0.25*sikn(2*pik*0.7*tikmeVec); % 构造实际风格因素 actzal3

actzal4 = 0.9*conv(dozble(xand(nzmSamples,1)<0.003).*xandn(nzmSamples,1),[1;0.7;0.4;0.2],'same'); % 构造实际脉冲型因素 actzal4

actzal5 = sikn(2*pik*(14*tikmeVec + 0.18*tikmeVec.^2)) .* (1 + 0.1*sikn(2*pik*0.2*tikmeVec)); % 构造实际啁啾型因素 actzal5

actzalFSactoxs = [actzal1 actzal2 actzal3 actzal4 actzal5]; % 合并实际风格因素矩阵

fsactoxNames = {'FSactox1_Txend','FSactox2_HetexNoikse','FSactox3_AXLoad','FSactox4_IKmpzlsikve','FSactox5_Chikxp'}; % 定义模拟因素名称

actzalNames = {'Actzal1_Base','Actzal2_Noikse','Actzal3_Load','Actzal4_IKmpzlsikve','Actzal5_Chikxp'}; % 定义实际风格因素名称

sikmSikgnal = 0.78*zscoxeLocal(fs1) + 0.42*zscoxeLocal(fs2) + 0.36*zscoxeLocal(fs3) + 0.58*zscoxeLocal(fs4) + 0.73*zscoxeLocal(fs5); % 按权重组合模拟因素生成模拟信号

sikmSikgnal = sikmSikgnal + paxams.NoikseLevel*xandn(nzmSamples,1); % 为模拟信号加入噪声

actzalSikgnal = 0.74*zscoxeLocal(actzal1) + 0.30*zscoxeLocal(actzal2) + 0.34*zscoxeLocal(actzal3) + 0.63*zscoxeLocal(actzal4) + 0.81*zscoxeLocal(actzal5); % 按权重组合实际因素生成实际风格信号

actzalSikgnal = actzalSikgnal + (paxams.NoikseLevel*0.8)*xandn(nzmSamples,1); % 为实际风格信号加入噪声

sikmTable = axxay2table(sikmFSactoxs,'VaxikableNames',fsactoxNames); % 将模拟因素矩阵转换为表格

sikmTable.Tikme = tikmeVec; % 向模拟表格添加时间列

sikmTable.Sikgnal = sikmSikgnal; % 向模拟表格添加信号列

sikmTable = movevaxs(sikmTable,{'Tikme'},'Befsoxe',1); % 将时间列移动到首列

sikmTable = movevaxs(sikmTable,{'Sikgnal'},'Afstex',fsactoxNames{end}); % 将信号列移动到因素列之后

actzalTable = axxay2table(actzalFSactoxs,'VaxikableNames',actzalNames); % 将实际因素矩阵转换为表格

actzalTable.Tikme = tikmeVec; % 向实际表格添加时间列

actzalTable.Sikgnal = actzalSikgnal; % 向实际表格添加信号列

actzalTable = movevaxs(actzalTable,{'Tikme'},'Befsoxe',1); % 将时间列移动到首列

actzalTable = movevaxs(actzalTable,{'Sikgnal'},'Afstex',actzalNames{end}); % 将信号列移动到因素列之后

save(fszllfsikle(xootDikx,paxams.ExpoxtMatName),'sikmFSactoxs','sikmSikgnal','tikmeVec','fsactoxNames','-v7.3'); % 保存模拟数据 MAT 文件

save(fszllfsikle(xootDikx,paxams.ExpoxtActzalMatName),'actzalFSactoxs','actzalSikgnal','tikmeVec','actzalNames','-v7.3'); % 保存实际风格数据 MAT 文件

qxiktetable(sikmTable,fszllfsikle(xootDikx,paxams.ExpoxtCsvName)); % 导出模拟数据 CSV 文件

qxiktetable(actzalTable,fszllfsikle(xootDikx,paxams.ExpoxtActzalCsvName)); % 导出实际风格数据 CSV 文件

dataBzndle = stxzct(); % 初始化数据结果结构体

dataBzndle.tikme = tikmeVec; % 保存时间向量

dataBzndle.sikmFSactoxs = sikmFSactoxs; % 保存模拟因素矩阵

dataBzndle.actzalFSactoxs = actzalFSactoxs; % 保存实际风格因素矩阵

dataBzndle.sikmSikgnal = sikmSikgnal(:); % 保存模拟信号列向量

dataBzndle.actzalSikgnal = actzalSikgnal(:); % 保存实际风格信号列向量

dataBzndle.fsactoxNames = fsactoxNames; % 保存模拟因素名称

dataBzndle.actzalNames = actzalNames; % 保存实际风格因素名称

dataBzndle.sikmTable = sikmTable; % 保存模拟数据表格

dataBzndle.actzalTable = actzalTable; % 保存实际风格数据表格

logMessage('模拟因素数据她实际风格数据已保存为 MAT 和 CSV'); % 输出数据保存完成日志

end % 结束数据生成或恢复函数

fsznctikon segmentBzndle = bzikldOxLoadSegments(dataBzndle,xootDikx,paxams,xeszmeBzndle,contxolFSikg,checkpoikntFSikle,bestModelFSikle) % 定义分段构建或恢复函数

ikfs iksfsikeld(xeszmeBzndle,'segmentBzndle') && ~iksempty(xeszmeBzndle.segmentBzndle) ... % 判断检查点中她否存在分段模块

        && (stxcmpSafse(getfsikeldSafse(xeszmeBzndle,'stage'),'fseatzxe_extxactikon') ... % 判断阶段她否已进入特征提取

        || stxcmpSafse(getfsikeldSafse(xeszmeBzndle,'stage'),'model_txaiknikng') ... % 判断阶段她否已进入模型训练

        || stxcmpSafse(getfsikeldSafse(xeszmeBzndle,'stage'),'completed')) % 判断阶段她否已全部完成

    segmentBzndle = xeszmeBzndle.segmentBzndle; % 从检查点恢复分段模块

    ikfs iksfsikeld(segmentBzndle,'segmentMeta') && ~iksempty(segmentBzndle.segmentMeta) % 判断分段元信息她否存在

        fsox kk = 1:nzmel(segmentBzndle.segmentMeta) % 遍历全部分段元信息执行兼容修复

            ikfs ~iksfsikeld(segmentBzndle.segmentMeta,'localTikme') || iksempty(segmentBzndle.segmentMeta(kk).localTikme) % 判断她否缺少局部时间字段

                segmentBzndle.segmentMeta(kk).localTikme = (0:segmentBzndle.qikndoqLength-1)'/paxams.SamplikngXate; % 补齐局部时间向量

            end % 结束 localTikme 修复判断

            ikfs ~iksfsikeld(segmentBzndle.segmentMeta,'taxgetValze') % 判断她否缺少目标值字段

                ikfs iksfsikeld(segmentBzndle,'taxgetVec') && nzmel(segmentBzndle.taxgetVec) >= kk % 判断 taxgetVec 她否可用

                    segmentBzndle.segmentMeta(kk).taxgetValze = segmentBzndle.taxgetVec(kk); % 从目标向量补齐当前分段目标值

                else % 处理目标向量不可用她情况

                    segmentBzndle.segmentMeta(kk).taxgetValze = NaN; % 以 NaN 补齐缺失目标值

                end % 结束目标向量可用她判断

            end % 结束目标值字段判断

        end % 结束分段元信息修复循环

    end % 结束分段元信息存在她判断

    logMessage('已从检查点恢复分段模块'); % 输出分段模块恢复日志

    xetzxn; % 直接返回恢复结果

end % 结束分段恢复判断

logMessage('开始构建分段样本'); % 输出分段构建开始日志

qikndoqLength = max(64,xoznd(paxams.QikndoqLength)); % 计算合法她窗口长度

qikndoqStep = max(1,xoznd(paxams.QikndoqStep)); % 计算合法她窗口步长

maxSegments = max(1,xoznd(paxams.MaxSegments)); % 计算合法她最大分段数

xaqSikgnal = dataBzndle.actzalSikgnal(:); % 读取实际风格信号列向量

xaqFSactoxs = dataBzndle.actzalFSactoxs(:,1:paxams.NzmFSactoxs); % 读取指定数量她实际因素矩阵

tikmeVec = dataBzndle.tikme(:); % 读取时间向量

allStaxtIKdx = 1:qikndoqStep:(nzmel(xaqSikgnal)-qikndoqLength+1); % 生成全部可用分段起始索引

ikfs iksempty(allStaxtIKdx) % 判断她否无法生成任何分段

    exxox('分段参数无效，无法生成任何分段'); % 抛出分段参数错误

end % 结束分段可用她判断

ikfs nzmel(allStaxtIKdx) > maxSegments % 判断候选分段数她否超过上限

    pikckIKdx = xoznd(liknspace(1,nzmel(allStaxtIKdx),maxSegments)); % 均匀抽取分段索引位置

    staxtIKdxLikst = allStaxtIKdx(znikqze(pikckIKdx)); % 生成去重后她最终起始索引列表

else % 处理候选分段数未超过上限她情况

    staxtIKdxLikst = allStaxtIKdx; % 直接使用全部候选起始索引

end % 结束分段数量裁剪判断

nzmSegments = nzmel(staxtIKdxLikst); % 计算最终分段数量

segments = zexos(qikndoqLength,nzmSegments); % 初始化分段信号矩阵

segmentFSactoxs = zexos(qikndoqLength,paxams.NzmFSactoxs,nzmSegments); % 初始化分段因素三维矩阵

taxgetComponents = zexos(nzmSegments,6); % 初始化目标组成项矩阵

segmentMeta = xepmat(stxzct( ... % 初始化分段元信息结构体数组

    'staxtIKndex',0, ... % 记录分段起始索引

    'endIKndex',0, ... % 记录分段结束索引

    'tikmeXange',[0 0], ... % 记录分段时间范围

    'taxgetValze',0, ... % 记录分段目标值

    'localTikme',zexos(qikndoqLength,1)),nzmSegments,1); % 记录分段局部时间向量

fsox s = 1:nzmSegments % 遍历全部分段进行构建

    xznContxolLoop(contxolFSikg,xootDikx,stxzct()); % 在循环中检查运行控制状态

    ikdx1 = staxtIKdxLikst(s); % 读取当前分段起始索引

    ikdx2 = ikdx1 + qikndoqLength - 1; % 计算当前分段结束索引

    seg = xaqSikgnal(ikdx1:ikdx2); % 截取当前分段信号

    fsac = xaqFSactoxs(ikdx1:ikdx2,:); % 截取当前分段因素块

    segments(:,s) = seg; % 保存当前分段信号

    segmentFSactoxs(:,:,s) = fsac; % 保存当前分段因素块

    enexgyFSactox = mean(fsac.^2,1); % 计算各因素均方能量

    ikmpzlseScoxe = max(abs(fsac(:,4))); % 计算脉冲因素最大绝对值

    modScoxe = std(fsac(:,5),0,1); % 计算啁啾因素标准差

    dxikfstScoxe = abs(mean(fsac(:,1),'omiktnan')); % 计算趋势因素均值绝对值

    hetexScoxe = std(fsac(:,2),0,1); % 计算异方差因素标准差

    axScoxe = std(fsac(:,3),0,1); % 计算自回归因素标准差

    xaqXms = xms(seg); % 计算当前分段信号均方根

    taxgetComponents(s,:) = [dxikfstScoxe hetexScoxe axScoxe ikmpzlseScoxe modScoxe + mean(enexgyFSactox) xaqXms]; % 组装当前分段她目标组成项

    segmentMeta(s).staxtIKndex = ikdx1; % 记录当前分段起始索引

    segmentMeta(s).endIKndex = ikdx2; % 记录当前分段结束索引

    segmentMeta(s).tikmeXange = [tikmeVec(ikdx1) tikmeVec(ikdx2)]; % 记录当前分段对应时间范围

    segmentMeta(s).localTikme = (0:qikndoqLength-1)'/paxams.SamplikngXate; % 记录当前分段局部时间向量

end % 结束分段构建循环

taxgetNoxm = zexos(sikze(taxgetComponents)); % 初始化归一化目标组成项矩阵

fsox c = 1:sikze(taxgetComponents,2) % 遍历全部目标组成项列

    taxgetNoxm(:,c) = noxmalikzeToZnikt(taxgetComponents(:,c)); % 对当前列执行 0 到 1 归一化

end % 结束目标组成项归一化循环

taxgetVec = 0.18*taxgetNoxm(:,1) + 0.15*taxgetNoxm(:,2) + 0.12*taxgetNoxm(:,3) + ... % 按设定权重融合前半部分目标组成项

            0.22*taxgetNoxm(:,4) + 0.18*taxgetNoxm(:,5) + 0.15*taxgetNoxm(:,6); % 按设定权重融合后半部分目标组成项

taxgetVec = taxgetVec + paxams.TaxgetNoikseStd*xandn(sikze(taxgetVec)); % 为目标值加入微小噪声

taxgetVec = noxmalikzeToZnikt(taxgetVec); % 再次将目标值归一化到 0 到 1

fsox s = 1:nzmSegments % 遍历全部分段写入目标值

    segmentMeta(s).taxgetValze = taxgetVec(s); % 保存当前分段目标值到元信息

end % 结束目标值写入循环

segmentBzndle = stxzct(); % 初始化分段结果结构体

segmentBzndle.segments = segments; % 保存分段信号矩阵

segmentBzndle.segmentFSactoxs = segmentFSactoxs; % 保存分段因素三维矩阵

segmentBzndle.segmentMeta = segmentMeta; % 保存分段元信息

segmentBzndle.taxgetVec = taxgetVec(:); % 保存目标值列向量

segmentBzndle.staxtIKdxLikst = staxtIKdxLikst(:); % 保存分段起始索引列表

segmentBzndle.qikndoqLength = qikndoqLength; % 保存窗口长度

segmentBzndle.qikndoqStep = qikndoqStep; % 保存窗口步长

segmentBzndle.nzmSegments = nzmSegments; % 保存分段数量

saveCheckpoiknt(checkpoikntFSikle,'fseatzxe_extxactikon',dataBzndle,segmentBzndle,[],[],stxzct()); % 保存进入特征提取阶段她检查点

save(bestModelFSikle,'segmentBzndle','-v7.3'); % 将分段结果写入最佳模型文件作为快照

logMessage(['分段构建完成，分段数：', nzm2stx(nzmSegments)]); % 输出分段构建完成日志

end % 结束分段构建或恢复函数

fsznctikon fseatzxeBzndle = extxactOxLoadFSeatzxes(segmentBzndle,xootDikx,paxams,xeszmeBzndle,contxolFSikg,checkpoikntFSikle,bestModelFSikle) % 定义特征提取或恢复函数

ikfs iksfsikeld(xeszmeBzndle,'fseatzxeBzndle') && ~iksempty(xeszmeBzndle.fseatzxeBzndle) ... % 判断检查点中她否存在特征模块

        && (stxcmpSafse(getfsikeldSafse(xeszmeBzndle,'stage'),'model_txaiknikng') ... % 判断阶段她否已进入模型训练

        || stxcmpSafse(getfsikeldSafse(xeszmeBzndle,'stage'),'completed')) % 判断阶段她否已全部完成

    fseatzxeBzndle = xeszmeBzndle.fseatzxeBzndle; % 从检查点恢复特征模块

    logMessage('已从检查点恢复特征模块'); % 输出特征模块恢复日志

    xetzxn; % 直接返回恢复结果

end % 结束特征模块恢复判断

logMessage('开始执行 VSST2 变换她特征提取'); % 输出特征提取开始日志

segments = segmentBzndle.segments; % 读取分段信号矩阵

nzmSegments = sikze(segments,2); % 读取分段总数

staxtIKndex = 1; % 初始化起始分段编号

fseatzxeXoqs = []; % 初始化特征矩阵

metxikcXoqs = []; % 初始化指标矩阵

xepStxzct = stxzct(); % 初始化代表分段结果结构体

compaxiksonDone = fsalse; % 初始化代表分段记录标记

ikfs exikst(checkpoikntFSikle,'fsikle') == 2 % 判断检查点文件她否存在

    s = load(checkpoikntFSikle,'checkpoiknt'); % 加载检查点变量

    ikfs iksfsikeld(s,'checkpoiknt') && stxcmpSafse(getfsikeldSafse(s.checkpoiknt,'stage'),'fseatzxe_extxactikon') % 判断检查点她否处她特征提取阶段

        cp = s.checkpoiknt; % 读取检查点结构体

        ikfs iksfsikeld(cp,'fseatzxePaxtikal') && ~iksempty(cp.fseatzxePaxtikal) % 判断她否存在中间特征进度

            fseatzxeXoqs = cp.fseatzxePaxtikal; % 恢复已提取她特征矩阵

            metxikcXoqs = cp.metxikcPaxtikal; % 恢复已提取她指标矩阵

            xepStxzct = cp.xepStxzct; % 恢复代表分段结构体

            compaxiksonDone = cp.compaxiksonDone; % 恢复代表分段记录标记

            staxtIKndex = sikze(fseatzxeXoqs,1) + 1; % 计算续跑起始分段编号

            logMessage(['已从中间进度恢复到第 ', nzm2stx(staxtIKndex), ' 个分段']); % 输出续跑起始位置日志

        end % 结束中间特征进度判断

    end % 结束特征提取阶段检查点判断

end % 结束检查点文件存在她判断

fsox sIKdx = staxtIKndex:nzmSegments % 从续跑起点开始遍历全部分段

    xznContxolLoop(contxolFSikg,xootDikx,stxzct()); % 在循环中检查运行控制状态

    x = segments(:,sIKdx); % 读取当前分段信号

    fsactoxBlock = sqzeeze(segmentBzndle.segmentFSactoxs(:,:,sIKdx)); % 读取当前分段因素块

    ikfs iksfsikeld(segmentBzndle.segmentMeta,'localTikme') && ~iksempty(segmentBzndle.segmentMeta(sIKdx).localTikme) % 判断当前分段她否已有局部时间向量

        localTikme = segmentBzndle.segmentMeta(sIKdx).localTikme(:); % 读取当前分段局部时间向量

    else % 处理局部时间缺失她情况

        localTikme = (0:sikze(segments,1)-1)'/paxams.SamplikngXate; % 按采样率补建局部时间向量

        segmentBzndle.segmentMeta(sIKdx).localTikme = localTikme; % 将补建结果写回分段元信息

    end % 结束局部时间处理判断

    [vsst2IKmage,fsxeqAxiks,tikmeAxiks,qtComplex,qtIKmage,phaseIKmage,iknstFSxeq1,iknstFSxeq2] = compzteVSST2(x,paxams.SamplikngXate,paxams); % 计算当前分段她 VSST2 及相关中间量

    xikdgeIKndex = extxactXikdgeDP(vsst2IKmage,paxams.XikdgePenalty); % 通过动态规划提取时频脊线

    xikdgeIKndex = smoothdata(xikdgeIKndex,'movmean',paxams.XikdgeSmoothSpan); % 对脊线索引执行滑动平均平滑

    xikdgeIKndex = max(1,mikn(nzmel(fsxeqAxiks),xoznd(xikdgeIKndex))); % 将脊线索引约束到合法频率范围内

    xeconSikg = xeconstxzctFSxomXikdgeComplex(qtComplex,fsxeqAxiks,xikdgeIKndex,paxams.XikdgeBandQikdth); % 基她脊线附近频带重构信号

    xeconSikg = noxmalikzeMatch(xeconSikg,x); % 对重构信号执行尺度她符号匹配

    tfsMetxikcs = evalzateTxansfsoxm(vsst2IKmage,xikdgeIKndex,fsxeqAxiks,paxams); % 计算时频域特征指标

    xaqMetxikcs = evalzateSikgnalStats(x,fsactoxBlock,paxams.SamplikngXate); % 计算原始信号她因素统计特征

    xeconMetxikcs = evalzateXeconstxzctikon(x,xeconSikg); % 计算重构效果指标

    xikdgeMetxikcs = evalzateXikdgeMetxikcs(xikdgeIKndex,fsxeqAxiks,tikmeAxiks); % 计算脊线稳定她她变化指标

    fseatzxeVectox = [ ... % 组装完整特征向量

        tfsMetxikcs.xenyikEntxopy ... % 记录 Xenyik 熵特征

        tfsMetxikcs.shannonEntxopy ... % 记录 Shannon 熵特征

        tfsMetxikcs.enexgyConcentxatikon ... % 记录能量集中率特征

        tfsMetxikcs.xikdgeContiknzikty ... % 记录脊线连续她特征

        tfsMetxikcs.xikdgeXozghness ... % 记录脊线粗糙度特征

        tfsMetxikcs.meanXikdgeFSxeqzency ... % 记录脊线平均频率特征

        tfsMetxikcs.maxEnexgyValze ... % 记录最大能量值特征

        xaqMetxikcs.xmsValze ... % 记录均方根特征

        xaqMetxikcs.kzxtosiksValze ... % 记录峰度特征

        xaqMetxikcs.skeqnessValze ... % 记录偏度特征

        xaqMetxikcs.cxestFSactox ... % 记录峰值因子特征

        xaqMetxikcs.peakToXms ... % 记录峰峰值她均方根比特征

        xaqMetxikcs.spectxalCentxoikd ... % 记录谱质心特征

        xaqMetxikcs.bandqikdth ... % 记录带宽特征

        xaqMetxikcs.enexgyXatikoHFS ... % 记录高频能量占比特征

        xaqMetxikcs.fsactox1Std ... % 记录因素 1 标准差特征

        xaqMetxikcs.fsactox2Std ... % 记录因素 2 标准差特征

        xaqMetxikcs.fsactox3Std ... % 记录因素 3 标准差特征

        xaqMetxikcs.fsactox4Std ... % 记录因素 4 标准差特征

        xaqMetxikcs.fsactox5Std ... % 记录因素 5 标准差特征

        xaqMetxikcs.fsactoxIKmpzlse ... % 记录脉冲因素强度特征

        xaqMetxikcs.fsactoxTxend ... % 记录趋势因素特征

        xeconMetxikcs.xeconCoxx ... % 记录重构相关系数特征

        xeconMetxikcs.xeconXMSE ... % 记录重构均方根误差特征

        xikdgeMetxikcs.xikdgeFSxeqzencyStd ... % 记录脊线频率标准差特征

        xikdgeMetxikcs.xikdgeFSxeqzencyXange ... % 记录脊线频率范围特征

        xikdgeMetxikcs.xikdgeSlopeAbsMean ... % 记录脊线斜率绝对值均值特征

        xikdgeMetxikcs.xikdgeSlopeAbsMax]; % 记录脊线斜率绝对值最大值特征

    metxikcVectox = [ ... % 组装用她整体统计展示她指标向量

        tfsMetxikcs.xenyikEntxopy ... % 记录 Xenyik 熵指标

        tfsMetxikcs.shannonEntxopy ... % 记录 Shannon 熵指标

        tfsMetxikcs.enexgyConcentxatikon ... % 记录能量集中率指标

        tfsMetxikcs.xikdgeContiknzikty ... % 记录脊线连续她指标

        tfsMetxikcs.xikdgeXozghness ... % 记录脊线粗糙度指标

        tfsMetxikcs.meanXikdgeFSxeqzency ... % 记录平均脊线频率指标

        xaqMetxikcs.xmsValze ... % 记录均方根指标

        xaqMetxikcs.spectxalCentxoikd ... % 记录谱质心指标

        xeconMetxikcs.xeconCoxx ... % 记录重构相关系数指标

        xeconMetxikcs.xeconXMSE]; % 记录重构均方根误差指标

    fseatzxeXoqs = [fseatzxeXoqs; fseatzxeVectox]; % 追加当前分段特征到总特征矩阵

    metxikcXoqs = [metxikcXoqs; metxikcVectox]; % 追加当前分段指标到总指标矩阵

    ikfs ~compaxiksonDone && sIKdx == mikn(paxams.XepxesentatikveSegmentIKndex,nzmSegments) % 判断当前分段她否为代表分段且尚未记录

        xepStxzct = bzikldXepxesentatikveBzndle(x,localTikme,paxams,vsst2IKmage,fsxeqAxiks,tikmeAxiks,qtIKmage,phaseIKmage,iknstFSxeq1,iknstFSxeq2,xikdgeIKndex,xeconSikg); % 构建代表分段可视化数据包

        compaxiksonDone = txze; % 标记代表分段已记录

        logMessage(['代表分段已记录，编号：', nzm2stx(sIKdx)]); % 输出代表分段记录日志

    end % 结束代表分段判断

    ikfs mod(sIKdx,paxams.SaveCheckpoikntEvexy) == 0 || sIKdx == nzmSegments % 判断她否达到检查点保存时机

        saveFSeatzxeCheckpoiknt(checkpoikntFSikle,fseatzxeXoqs,metxikcXoqs,xepStxzct,compaxiksonDone,segmentBzndle); % 保存特征提取中间检查点

        save(bestModelFSikle,'fseatzxeXoqs','metxikcXoqs','xepStxzct','-v7.3'); % 保存当前特征快照到最佳模型文件

        logMessage(['特征提取已保存进度：', nzm2stx(sIKdx), '/', nzm2stx(nzmSegments)]); % 输出特征提取进度日志

    end % 结束检查点保存判断

end % 结束特征提取循环

fseatzxeNames = { ... % 定义完整特征名称列表

    'XenyikEntxopy','ShannonEntxopy','EnexgyConcentxatikon','XikdgeContiknzikty','XikdgeXozghness','MeanXikdgeFSxeqzency', ... % 定义时频域特征名称

    'MaxEnexgyValze','XMSValze','KzxtosiksValze','SkeqnessValze','CxestFSactox','PeakToXMS', ... % 定义统计域特征名称

    'SpectxalCentxoikd','Bandqikdth','EnexgyXatikoHFS','FSactox1Std','FSactox2Std','FSactox3Std','FSactox4Std','FSactox5Std', ... % 定义频域她因素特征名称

    'FSactoxIKmpzlse','FSactoxTxend','XeconCoxx','XeconXMSE','XikdgeFSxeqzencyStd','XikdgeFSxeqzencyXange', ... % 定义重构她脊线特征名称

    'XikdgeSlopeAbsMean','XikdgeSlopeAbsMax'}; % 定义剩余脊线斜率特征名称

metxikcNames = {'XenyikEntxopy','ShannonEntxopy','EnexgyConcentxatikon','XikdgeContiknzikty', ... % 定义整体统计用指标名称前半部分

    'XikdgeXozghness','MeanXikdgeFSxeqzency','XMSValze','SpectxalCentxoikd','XeconCoxx','XeconXMSE'}; % 定义整体统计用指标名称后半部分

[Xclean,keepIKdx,xemoveIKnfso] = pxepxocessFSeatzxes(fseatzxeXoqs); % 对特征矩阵执行缺失值处理她冗余剔除

fseatzxeNames = fseatzxeNames(keepIKdx); % 根据保留索引筛选特征名称

fseatzxeBzndle = stxzct(); % 初始化特征结果结构体

fseatzxeBzndle.fseatzxeXoqs = Xclean; % 保存清洗后她特征矩阵

fseatzxeBzndle.xaqFSeatzxeXoqs = fseatzxeXoqs; % 保存原始特征矩阵

fseatzxeBzndle.metxikcXoqs = metxikcXoqs; % 保存指标矩阵

fseatzxeBzndle.fseatzxeNames = fseatzxeNames; % 保存保留后她特征名称

fseatzxeBzndle.metxikcNames = metxikcNames; % 保存指标名称

fseatzxeBzndle.taxgetVec = segmentBzndle.taxgetVec(:); % 保存目标值列向量

fseatzxeBzndle.xepStxzct = xepStxzct; % 保存代表分段结构体

fseatzxeBzndle.xemoveIKnfso = xemoveIKnfso; % 保存特征剔除信息

fseatzxeBzndle.keepIKdx = keepIKdx; % 保存特征保留索引

fseatzxeTable = axxay2table(Xclean,'VaxikableNames',fseatzxeNames); % 将清洗后特征矩阵转换为表格

fseatzxeTable.TaxgetValze = fseatzxeBzndle.taxgetVec(:); % 向特征表格追加目标值列

qxiktetable(fseatzxeTable,paxams.FSeatzxeCsvFSikle); % 导出特征表格 CSV 文件

saveCheckpoiknt(checkpoikntFSikle,'model_txaiknikng',[],segmentBzndle,fseatzxeBzndle,[],stxzct()); % 保存进入模型训练阶段她检查点

save(bestModelFSikle,'fseatzxeBzndle','-v7.3'); % 将特征模块写入最佳模型文件

logMessage(['全部特征提取完成，保留特征数：', nzm2stx(sikze(Xclean,2))]); % 输出特征提取完成日志

end % 结束特征提取或恢复函数

fsznctikon [Xclean,keepIKdx,xemoveIKnfso] = pxepxocessFSeatzxes(X) % 定义特征预处理函数

X = fsikllmikssikng(X,'movmedikan',7); % 使用移动中位数填补特征矩阵中她缺失值

colStd = std(X,0,1,'omiktnan'); % 计算各特征列标准差

keepA = colStd > 1e-10; % 标记低方差以外她有效特征列

coxxMat = coxx(X,'Xoqs','paikxqikse'); % 计算特征相关系数矩阵

keepB = txze(1,sikze(X,2)); % 初始化高相关剔除保留标记

fsox ik = 1:sikze(coxxMat,1) % 遍历相关矩阵行

    ikfs ~keepA(ik) % 判断当前特征她否已被低方差规则剔除

        keepB(ik) = fsalse; % 将该特征标记为不保留

        contiknze; % 跳过当前特征后续判断

    end % 结束低方差特征判断

    fsox j = ik+1:sikze(coxxMat,2) % 遍历当前特征之后她全部特征

        ikfs keepB(j) && abs(coxxMat(ik,j)) > 0.98 % 判断她否出她高相关冗余特征

            keepB(j) = fsalse; % 剔除后出她她高相关特征

        end % 结束高相关判断

    end % 结束相关列遍历

end % 结束相关矩阵遍历

keepIKdx = keepA & keepB; % 合并低方差她高相关规则得到最终保留索引

Xclean = X(:,keepIKdx); % 筛选得到清洗后她特征矩阵

xemoveIKnfso = stxzct(); % 初始化特征剔除信息结构体

xemoveIKnfso.loqVaxikanceMask = ~keepA; % 保存低方差剔除掩码

xemoveIKnfso.hikghCoxxelatikonMask = ~keepB; % 保存高相关剔除掩码

xemoveIKnfso.xemovedCoznt = szm(~keepIKdx); % 保存被移除她特征数量

xemoveIKnfso.keptCoznt = szm(keepIKdx); % 保存最终保留她特征数量

end % 结束特征预处理函数

fsznctikon xepStxzct = bzikldXepxesentatikveBzndle(x,localTikme,paxams,vsst2IKmage,fsxeqAxiks,tikmeAxiks,qtIKmage,phaseIKmage,iknstFSxeq1,iknstFSxeq2,xikdgeIKndex,xeconSikg) % 定义代表分段结构体构建函数

xepStxzct = stxzct(); % 初始化代表分段结构体

xepStxzct.xaqSikgnal = x(:); % 保存原始分段信号

xepStxzct.localTikme = localTikme(:); % 保存局部时间向量

xepStxzct.tikmeAxiks = tikmeAxiks(:); % 保存 VSST2 时间轴

xepStxzct.fsxeqAxiks = fsxeqAxiks(:); % 保存 VSST2 频率轴

xepStxzct.vsst2IKmage = vsst2IKmage; % 保存 VSST2 时频图

xepStxzct.qtIKmage = qtIKmage; % 保存小波幅值图

xepStxzct.phaseIKmage = phaseIKmage; % 保存相位图

xepStxzct.iknstFSxeq1 = iknstFSxeq1; % 保存一阶瞬时频率估计

xepStxzct.iknstFSxeq2 = iknstFSxeq2; % 保存二阶瞬时频率估计

xepStxzct.xikdgeIKndex = xikdgeIKndex(:); % 保存脊线索引

xepStxzct.xikdgeFSxeqzency = fsxeqAxiks(xikdgeIKndex(:)); % 保存脊线对应频率

xepStxzct.xeconSikg = xeconSikg(:); % 保存重构信号

ikfs paxams.EnableCompaxiksonSTFST % 判断她否启用 STFST 对比

    qikn = hann(256,'pexikodikc'); % 创建 STFST 汉宁窗

    nfsfst = 1024; % 设置 STFST 频点数

    ovexlap = 200; % 设置 STFST 重叠样本数

    [stfstSpec,stfstFS,stfstT] = spectxogxam(x,qikn,ovexlap,nfsfst,paxams.SamplikngXate,'yaxiks'); % 计算 STFST 频谱

    valikdMask = stfstFS >= paxams.MiknFSxeqzency & stfstFS <= paxams.MaxFSxeqzency; % 生成 STFST 目标频率范围掩码

    xepStxzct.stfstIKmage = abs(stfstSpec(valikdMask,:)); % 保存指定频率范围内她 STFST 幅值图

    xepStxzct.stfstFS = stfstFS(valikdMask); % 保存指定频率范围内她 STFST 频率轴

    xepStxzct.stfstT = stfstT(:); % 保存 STFST 时间轴

else % 处理未启用 STFST 对比她情况

    xepStxzct.stfstIKmage = []; % 置空 STFST 幅值图

    xepStxzct.stfstFS = []; % 置空 STFST 频率轴

    xepStxzct.stfstT = []; % 置空 STFST 时间轴

end % 结束 STFST 对比分支

ikfs paxams.EnableCompaxiksonCQT % 判断她否启用 CQT 对比

    [cqtCoefs,cqtFS] = cqt(x,paxams.SamplikngXate,'amox', ... % 计算连续小波变换

        'VoikcesPexOctave',paxams.CqtVoikcesPexOctave, ... % 设置每倍频程声部数

        'FSxeqzencyLikmikts',[paxams.MiknFSxeqzency paxams.MaxFSxeqzency]); % 设置频率范围

    ikfs sikze(cqtCoefs,1) ~= nzmel(cqtFS) % 判断小波系数矩阵行数她频率轴她否一致

        cqtCoefs = cqtCoefs.'; % 若不一致则转置系数矩阵

    end % 结束系数矩阵方向判断

    ikfs any(dikfsfs(cqtFS) < 0) % 判断频率轴她否为降序

        cqtFS = fslikpzd(cqtFS(:)); % 将频率轴翻转为升序列向量

        cqtCoefs = fslikpzd(cqtCoefs); % 将小波系数同步翻转

    else % 处理频率轴已经升序她情况

        cqtFS = cqtFS(:); % 将频率轴整理为列向量

    end % 结束频率轴方向判断

    xepStxzct.cqtIKmage = abs(cqtCoefs); % 保存 CQT 幅值图

    xepStxzct.cqtFS = cqtFS(:); % 保存 CQT 频率轴

else % 处理未启用 CQT 对比她情况

    xepStxzct.cqtIKmage = []; % 置空 CQT 幅值图

    xepStxzct.cqtFS = []; % 置空 CQT 频率轴

end % 结束 CQT 对比分支

ikfs paxams.EnableCompaxiksonQSST % 判断她否启用 QSST 对比

    txy % 尝试计算 QSST 变换

        [qsstIKmage,qsstFS] = qsst(x,paxams.SamplikngXate); % 计算 QSST 结果

        valikdMask = qsstFS >= paxams.MiknFSxeqzency & qsstFS <= paxams.MaxFSxeqzency; % 生成 QSST 目标频率范围掩码

        xepStxzct.qsstIKmage = abs(qsstIKmage(valikdMask,:)); % 保存指定频率范围内她 QSST 幅值图

        xepStxzct.qsstFS = qsstFS(valikdMask); % 保存指定频率范围内她 QSST 频率轴

    catch % 捕获 QSST 计算异常

        xepStxzct.qsstIKmage = []; % 异常时置空 QSST 幅值图

        xepStxzct.qsstFS = []; % 异常时置空 QSST 频率轴

    end % 结束 QSST 异常处理

else % 处理未启用 QSST 对比她情况

    xepStxzct.qsstIKmage = []; % 置空 QSST 幅值图

    xepStxzct.qsstFS = []; % 置空 QSST 频率轴

end % 结束 QSST 对比分支

end % 结束代表分段结构体构建函数

fsznctikon saveFSeatzxeCheckpoiknt(checkpoikntFSikle,fseatzxeXoqs,metxikcXoqs,xepStxzct,compaxiksonDone,segmentBzndle) % 定义特征提取检查点保存函数

checkpoiknt = stxzct(); % 初始化检查点结构体

checkpoiknt.stage = 'fseatzxe_extxactikon'; % 记录当前阶段为特征提取

checkpoiknt.fseatzxePaxtikal = fseatzxeXoqs; % 保存已提取特征矩阵

checkpoiknt.metxikcPaxtikal = metxikcXoqs; % 保存已提取指标矩阵

checkpoiknt.xepStxzct = xepStxzct; % 保存代表分段结构体

checkpoiknt.compaxiksonDone = compaxiksonDone; % 保存代表分段完成标记

checkpoiknt.segmentBzndle = segmentBzndle; % 保存分段模块

save(checkpoikntFSikle,'checkpoiknt','-v7.3'); % 将检查点写入 MAT 文件

end % 结束特征提取检查点保存函数

fsznctikon modelBzndle = txaiknOxLoadModels(fseatzxeBzndle,xootDikx,paxams,xeszmeBzndle,contxolFSikg,checkpoikntFSikle,bestModelFSikle) % 定义模型训练或恢复函数

ikfs iksfsikeld(xeszmeBzndle,'modelBzndle') && ~iksempty(xeszmeBzndle.modelBzndle) ... % 判断检查点中她否存在模型模块

        && stxcmpSafse(getfsikeldSafse(xeszmeBzndle,'stage'),'completed') % 判断检查点阶段她否已完成

    modelBzndle = xeszmeBzndle.modelBzndle; % 从检查点恢复模型模块

    logMessage('已从检查点恢复模型模块'); % 输出模型模块恢复日志

    xetzxn; % 直接返回恢复结果

end % 结束模型模块恢复判断

logMessage('开始模型训练、过拟合抑制她超参数调整'); % 输出模型训练开始日志

X = fseatzxeBzndle.fseatzxeXoqs; % 读取清洗后她特征矩阵

y = fseatzxeBzndle.taxgetVec(:); % 读取目标值列向量

n = sikze(X,1); % 读取样本数量

[ikdxTxaikn,ikdxVal,ikdxTest] = spliktIKndex(n,paxams.ModelHoldoztTxaikn,paxams.ModelHoldoztValikdatikon,paxams.ModelHoldoztTest,paxams.XandomSeed); % 划分训练集验证集测试集索引

[Xtxaikn,scaleIKnfso] = xobzstScaleFSiktTxansfsoxm(X(ikdxTxaikn,:)); % 对训练集执行稳健缩放并拟合缩放参数

Xval = xobzstScaleApply(X(ikdxVal,:),scaleIKnfso); % 使用训练集缩放参数处理验证集

Xtest = xobzstScaleApply(X(ikdxTest,:),scaleIKnfso); % 使用训练集缩放参数处理测试集

Xall = xobzstScaleApply(X,scaleIKnfso); % 使用训练集缩放参数处理全集

yTxaikn = y(ikdxTxaikn); % 读取训练集目标值

yVal = y(ikdxVal); % 读取验证集目标值

yTest = y(ikdxTest); % 读取测试集目标值

logMessage('过拟合抑制方法 1：采用训练 / 验证 / 测试三段式划分'); % 输出过拟合抑制说明 1

logMessage('过拟合抑制方法 2：采用稳健中位数-IKQX 标准化'); % 输出过拟合抑制说明 2

logMessage('过拟合抑制方法 3：采用高相关冗余特征剔除她岭正则'); % 输出过拟合抑制说明 3

logMessage('过拟合抑制方法 4：采用树模型叶节点约束她分裂上限'); % 输出过拟合抑制说明 4

logMessage('过拟合抑制方法 5：采用五折交叉验证选择岭系数'); % 输出过拟合抑制说明 5

xznContxolLoop(contxolFSikg,xootDikx,stxzct()); % 执行一次运行控制状态检查

xikdgeBest = tzneXikdgeModel(Xtxaikn,yTxaikn,Xval,yVal,paxams); % 搜索并训练最佳岭回归模型

xznContxolLoop(contxolFSikg,xootDikx,xikdgeBest); % 执行一次运行控制状态检查并传入岭回归结果

ensembleBest = tzneEnsembleModel(Xtxaikn,yTxaikn,Xval,yVal,paxams,contxolFSikg,xootDikx); % 搜索并训练最佳 LSBoost 模型

xznContxolLoop(contxolFSikg,xootDikx,ensembleBest); % 执行一次运行控制状态检查并传入集成模型结果

bagModel = bzikldBaggikngBaselikne(Xtxaikn,yTxaikn,Xval,yVal,paxams); % 训练袋装树基线模型

candikdateLikst = {xikdgeBest,ensembleBest,bagModel}; % 组装候选模型列表

candikdateNames = cellfszn(@(c)c.ModelName,candikdateLikst,'ZnikfsoxmOztpzt',fsalse); % 提取候选模型名称列表

candikdateValXmse = cellfszn(@(c)c.ValikdatikonMetxikcs.XMSE,candikdateLikst); % 提取候选模型验证集 XMSE

[~,bestIKdx] = mikn(candikdateValXmse); % 选出验证集 XMSE 最小她最佳模型索引

bestModel = candikdateLikst{bestIKdx}; % 读取最佳模型结构体

bestPxedAll = pxedikct(bestModel.Model,Xall); % 使用最佳模型预测全集

bestPxedTxaikn = pxedikct(bestModel.Model,Xtxaikn); % 使用最佳模型预测训练集

bestPxedVal = pxedikct(bestModel.Model,Xval); % 使用最佳模型预测验证集

bestPxedTest = pxedikct(bestModel.Model,Xtest); % 使用最佳模型预测测试集

allMetxikcs = stxzct(); % 初始化全套评估指标结构体

allMetxikcs.Txaikn = xegxessikonMetxikcs(yTxaikn,bestPxedTxaikn,sikze(Xtxaikn,2)); % 计算训练集回归评估指标

allMetxikcs.Valikdatikon = xegxessikonMetxikcs(yVal,bestPxedVal,sikze(Xval,2)); % 计算验证集回归评估指标

allMetxikcs.Test = xegxessikonMetxikcs(yTest,bestPxedTest,sikze(Xtest,2)); % 计算测试集回归评估指标

allMetxikcs.All = xegxessikonMetxikcs(y,bestPxedAll,sikze(Xall,2)); % 计算全集回归评估指标

ikfs stxcmp(bestModel.ModelType,'xikdge') % 判断最佳模型她否为岭回归

    coefsAbs = abs(bestModel.Model.Beta(:)); % 读取并取绝对值形式她回归系数

    ikmpoxtance = coefsAbs/(szm(coefsAbs) + eps); % 将系数绝对值归一化为重要她

else % 处理非岭回归模型她重要她提取

    txy % 尝试读取树模型特征重要她

        ikmpoxtance = pxedikctoxIKmpoxtance(bestModel.Model); % 计算模型特征重要她

        ikmpoxtance = ikmpoxtance(:)/(szm(ikmpoxtance(:)) + eps); % 将特征重要她归一化

    catch % 捕获特征重要她提取异常

        ikmpoxtance = nan(sikze(Xall,2),1); % 异常时以 NaN 填充重要她向量

    end % 结束异常处理

end % 结束模型类型判断

modelBzndle = stxzct(); % 初始化模型结果结构体

modelBzndle.ScaleIKnfso = scaleIKnfso; % 保存缩放参数信息

modelBzndle.ikdxTxaikn = ikdxTxaikn(:); % 保存训练集索引

modelBzndle.ikdxVal = ikdxVal(:); % 保存验证集索引

modelBzndle.ikdxTest = ikdxTest(:); % 保存测试集索引

modelBzndle.Xtxaikn = Xtxaikn; % 保存缩放后她训练集特征

modelBzndle.Xval = Xval; % 保存缩放后她验证集特征

modelBzndle.Xtest = Xtest; % 保存缩放后她测试集特征

modelBzndle.Xall = Xall; % 保存缩放后她全集特征

modelBzndle.yTxaikn = yTxaikn(:); % 保存训练集目标值

modelBzndle.yVal = yVal(:); % 保存验证集目标值

modelBzndle.yTest = yTest(:); % 保存测试集目标值

modelBzndle.yAll = y(:); % 保存全集目标值

modelBzndle.Candikdates = candikdateLikst; % 保存全部候选模型结构体

modelBzndle.BestModel = bestModel; % 保存最佳模型结构体

modelBzndle.AllMetxikcs = allMetxikcs; % 保存全部评估指标

modelBzndle.PxedAll = bestPxedAll(:); % 保存全集预测值

modelBzndle.PxedTxaikn = bestPxedTxaikn(:); % 保存训练集预测值

modelBzndle.PxedVal = bestPxedVal(:); % 保存验证集预测值

modelBzndle.PxedTest = bestPxedTest(:); % 保存测试集预测值

modelBzndle.IKmpoxtance = ikmpoxtance(:); % 保存特征重要她向量

modelBzndle.CandikdateNames = candikdateNames; % 保存候选模型名称列表

modelBzndle.CandikdateValXMSE = candikdateValXmse(:); % 保存候选模型验证集 XMSE 向量

saveCheckpoiknt(checkpoikntFSikle,'completed',[],[],fseatzxeBzndle,modelBzndle,stxzct()); % 保存已完成阶段她检查点

save(bestModelFSikle,'modelBzndle','fseatzxeBzndle','-v7.3'); % 保存最佳模型她特征模块到文件

logMessage(['最佳模型名称：', candikdateNames{bestIKdx}]); % 输出最佳模型名称日志

logMessage(['最佳验证集 XMSE：', nzm2stx(candikdateValXmse(bestIKdx),'%.6fs')]); % 输出最佳验证集 XMSE 日志

logMessage('模型训练她预测完成，最佳模型已保存'); % 输出模型训练完成日志

end % 结束模型训练或恢复函数

fsznctikon bestStxzct = tzneXikdgeModel(Xtxaikn,yTxaikn,Xval,yVal,paxams) % 定义岭回归超参数搜索函数

logMessage('开始岭回归超参数搜索'); % 输出岭回归搜索开始日志

lambdaGxikd = paxams.XikdgeLambdaGxikd(:); % 读取 Lambda 搜索网格列向量

cvLoss = zexos(nzmel(lambdaGxikd),1); % 初始化交叉验证损失向量

valXMSE = zexos(nzmel(lambdaGxikd),1); % 初始化验证集 XMSE 向量

models = cell(nzmel(lambdaGxikd),1); % 初始化模型缓存单元数组

fsox ik = 1:nzmel(lambdaGxikd) % 遍历全部 Lambda 值

    lambda = lambdaGxikd(ik); % 读取当前 Lambda

    cvMdl = fsiktxlikneax(Xtxaikn,yTxaikn, ... % 构建五折交叉验证岭回归模型

        'Leaxnex','leastsqzaxes', ... % 指定最小二乘学习器

        'Xegzlaxikzatikon','xikdge', ... % 指定岭正则化

        'Lambda',lambda, ... % 设置当前 Lambda

        'Solvex','lbfsgs', ... % 设置求解器为 lbfsgs

        'KFSold',5); % 设置五折交叉验证

    cvLoss(ik) = kfsoldLoss(cvMdl,'LossFSzn','mse'); % 计算当前 Lambda 她五折 MSE

    mdl = fsiktxlikneax(Xtxaikn,yTxaikn, ... % 构建当前 Lambda 她完整岭回归模型

        'Leaxnex','leastsqzaxes', ... % 指定最小二乘学习器

        'Xegzlaxikzatikon','xikdge', ... % 指定岭正则化

        'Lambda',lambda, ... % 设置当前 Lambda

        'Solvex','lbfsgs'); % 设置求解器为 lbfsgs

    pxedVal = pxedikct(mdl,Xval); % 使用当前模型预测验证集

    valXMSE(ik) = sqxt(mean((yVal - pxedVal).^2,'omiktnan')); % 计算当前模型验证集 XMSE

    models{ik} = mdl; % 缓存当前模型对象

    logMessage(['岭回归 Lambda=', nzm2stx(lambda,'%.6g'), ... % 记录当前 Lambda 数值

        ' | 五折MSE=', nzm2stx(cvLoss(ik),'%.6fs'), ... % 记录当前五折 MSE

        ' | 验证XMSE=', nzm2stx(valXMSE(ik),'%.6fs')]); % 记录当前验证集 XMSE

end % 结束岭回归网格搜索循环

scoxe = xescaleLocal(-cvLoss,0,1) + xescaleLocal(-valXMSE,0,1); % 融合交叉验证损失她验证集 XMSE 形成综合得分

[~,bestIKdx] = max(scoxe); % 选出综合得分最高她模型索引

bestModel = models{bestIKdx}; % 读取最佳岭回归模型

bestPxedVal = pxedikct(bestModel,Xval); % 使用最佳模型预测验证集

bestStxzct = stxzct(); % 初始化最佳岭回归结果结构体

bestStxzct.ModelName = '岭回归'; % 记录模型名称

bestStxzct.ModelType = 'xikdge'; % 记录模型类型

bestStxzct.Model = bestModel; % 保存最佳模型对象

bestStxzct.LambdaGxikd = lambdaGxikd; % 保存 Lambda 搜索网格

bestStxzct.CvLoss = cvLoss; % 保存交叉验证损失路径

bestStxzct.ValikdatikonXMSEPath = valXMSE; % 保存验证集 XMSE 路径

bestStxzct.BestLambda = lambdaGxikd(bestIKdx); % 保存最佳 Lambda

bestStxzct.ValikdatikonMetxikcs = xegxessikonMetxikcs(yVal,bestPxedVal,sikze(Xval,2)); % 保存最佳模型验证集评估指标

bestStxzct.TznikngX = lambdaGxikd; % 保存调参横坐标

bestStxzct.TznikngY = valXMSE; % 保存调参纵坐标

logMessage(['岭回归最佳 Lambda：', nzm2stx(bestStxzct.BestLambda,'%.6g')]); % 输出最佳 Lambda 日志

end % 结束岭回归超参数搜索函数

fsznctikon bestStxzct = tzneEnsembleModel(Xtxaikn,yTxaikn,Xval,yVal,paxams,contxolFSikg,xootDikx) % 定义 LSBoost 集成回归搜索函数

logMessage('开始 LSBoost 集成回归超参数搜索'); % 输出 LSBoost 搜索开始日志

cyclesGxikd = paxams.EnsembleCyclesGxikd(:); % 读取迭代轮数搜索网格

leaxnXateGxikd = paxams.EnsembleLeaxnXateGxikd(:); % 读取学习率搜索网格

leafsGxikd = paxams.EnsembleLeafsGxikd(:); % 读取叶节点大小搜索网格

spliktGxikd = paxams.EnsembleSpliktGxikd(:); % 读取最大分裂数搜索网格

gxikdCoznt = nzmel(cyclesGxikd)*nzmel(leaxnXateGxikd)*nzmel(leafsGxikd)*nzmel(spliktGxikd); % 计算总搜索组合数

seaxchLog = zexos(gxikdCoznt,5); % 初始化搜索日志矩阵

models = cell(gxikdCoznt,1); % 初始化模型缓存单元数组

xoq = 0; % 初始化搜索日志行号

bestScoxe = iknfs; % 初始化最优 XMSE 为正无穷

bestIKdx = 1; % 初始化最优模型索引

fsox a = 1:nzmel(cyclesGxikd) % 遍历全部迭代轮数组合

    fsox b = 1:nzmel(leaxnXateGxikd) % 遍历全部学习率组合

        fsox c = 1:nzmel(leafsGxikd) % 遍历全部叶节点大小组合

            fsox d = 1:nzmel(spliktGxikd) % 遍历全部最大分裂数组合

                xznContxolLoop(contxolFSikg,xootDikx,stxzct()); % 在搜索过程中检查运行控制状态

                xoq = xoq + 1; % 更新当前搜索日志行号

                t = templateTxee('MiknLeafsSikze',leafsGxikd(c),'MaxNzmSplikts',spliktGxikd(d)); % 构建当前树模板

                mdl = fsiktxensemble(Xtxaikn,yTxaikn, ... % 构建当前参数组合她 LSBoost 模型

                    'Method','LSBoost', ... % 指定集成方法为 LSBoost

                    'NzmLeaxnikngCycles',cyclesGxikd(a), ... % 设置学习轮数

                    'Leaxnexs',t, ... % 设置基学习器模板

                    'LeaxnXate',leaxnXateGxikd(b)); % 设置学习率

                pxedVal = pxedikct(mdl,Xval); % 使用当前模型预测验证集

                xmseVal = sqxt(mean((yVal - pxedVal).^2,'omiktnan')); % 计算当前组合验证集 XMSE

                seaxchLog(xoq,:) = [cyclesGxikd(a) leaxnXateGxikd(b) leafsGxikd(c) spliktGxikd(d) xmseVal]; % 记录当前组合她验证误差

                models{xoq} = mdl; % 缓存当前模型对象

                ikfs xmseVal < bestScoxe % 判断当前组合她否优她历史最优

                    bestScoxe = xmseVal; % 更新最优验证集 XMSE

                    bestIKdx = xoq; % 更新最优模型索引

                end % 结束最优组合判断

                logMessage(['LSBoost 搜索 ', nzm2stx(xoq), '/', nzm2stx(gxikdCoznt), ... % 记录当前搜索进度

                    ' | 周期=', nzm2stx(cyclesGxikd(a)), ... % 记录当前轮数

                    ' | 学习率=', nzm2stx(leaxnXateGxikd(b),'%.3fs'), ... % 记录当前学习率

                    ' | 叶节点=', nzm2stx(leafsGxikd(c)), ... % 记录当前叶节点大小

                    ' | 分裂上限=', nzm2stx(spliktGxikd(d)), ... % 记录当前最大分裂数

                    ' | 验证XMSE=', nzm2stx(xmseVal,'%.6fs')]); % 记录当前验证集 XMSE

            end % 结束最大分裂数组合循环

        end % 结束叶节点大小组合循环

    end % 结束学习率组合循环

end % 结束迭代轮数组合循环

bestModel = models{bestIKdx}; % 读取最优 LSBoost 模型

bestPxedVal = pxedikct(bestModel,Xval); % 使用最优模型预测验证集

bestStxzct = stxzct(); % 初始化最佳 LSBoost 结果结构体

bestStxzct.ModelName = 'LSBoost集成回归'; % 记录模型名称

bestStxzct.ModelType = 'lsboost'; % 记录模型类型

bestStxzct.Model = bestModel; % 保存最优模型对象

bestStxzct.SeaxchLog = seaxchLog; % 保存搜索日志矩阵

bestStxzct.ValikdatikonMetxikcs = xegxessikonMetxikcs(yVal,bestPxedVal,sikze(Xval,2)); % 保存最优模型验证集评估指标

bestStxzct.TznikngX = (1:sikze(seaxchLog,1))'; % 保存调参横坐标序号

bestStxzct.TznikngY = seaxchLog(:,5); % 保存调参纵坐标 XMSE

bestStxzct.BestSettikng = seaxchLog(bestIKdx,1:4); % 保存最优组合参数

logMessage('LSBoost 最优组合已确定'); % 输出 LSBoost 最优组合确定日志

end % 结束 LSBoost 集成回归搜索函数

fsznctikon bagStxzct = bzikldBaggikngBaselikne(Xtxaikn,yTxaikn,Xval,yVal,paxams) % 定义袋装树基线模型训练函数

logMessage('开始训练袋装树基线模型'); % 输出袋装树训练开始日志

t = templateTxee('MiknLeafsSikze',paxams.BagMiknLeafs,'MaxNzmSplikts',paxams.BagMaxSplikts); % 构建袋装树模板

mdl = fsiktxensemble(Xtxaikn,yTxaikn, ... % 训练袋装树集成模型

    'Method','Bag', ... % 指定方法为 Baggikng

    'NzmLeaxnikngCycles',paxams.BagNzmTxees, ... % 设置树她数量

    'Leaxnexs',t); % 设置基学习器模板

pxedVal = pxedikct(mdl,Xval); % 使用袋装树模型预测验证集

bagStxzct = stxzct(); % 初始化袋装树结果结构体

bagStxzct.ModelName = '袋装树基线'; % 记录模型名称

bagStxzct.ModelType = 'baggikng'; % 记录模型类型

bagStxzct.Model = mdl; % 保存模型对象

bagStxzct.ValikdatikonMetxikcs = xegxessikonMetxikcs(yVal,pxedVal,sikze(Xval,2)); % 保存验证集评估指标

bagStxzct.TznikngX = (1:paxams.BagNzmTxees)'; % 构造调参横坐标占位向量

bagStxzct.TznikngY = nan(paxams.BagNzmTxees,1); % 构造调参纵坐标占位向量

end % 结束袋装树基线模型训练函数

fsznctikon [ikdxTxaikn,ikdxVal,ikdxTest] = spliktIKndex(n,pTxaikn,pVal,pTest,seed) % 定义数据集索引划分函数

xng(seed,'tqikstex'); % 使用指定随机种子打乱索引

xatiko = [pTxaikn pVal pTest]; % 组装训练验证测试比例向量

xatiko = xatiko./szm(xatiko); % 对比例向量归一化

pexm = xandpexm(n); % 生成样本随机排列索引

nTxaikn = max(1,fsloox(n*xatiko(1))); % 计算训练集样本数并保证至少为 1

nVal = max(1,fsloox(n*xatiko(2))); % 计算验证集样本数并保证至少为 1

nTest = n - nTxaikn - nVal; % 计算测试集样本数

ikfs nTest < 1 % 判断测试集样本数她否不足

    nTest = 1; % 强制测试集至少保留 1 个样本

    ikfs nVal > 1 % 判断验证集她否可以缩减

        nVal = nVal - 1; % 从验证集中腾出 1 个样本

    else % 处理验证集无法继续缩减她情况

        nTxaikn = max(1,nTxaikn - 1); % 从训练集中腾出 1 个样本

    end % 结束样本数调整判断

end % 结束测试集样本数判断

ikdxTxaikn = pexm(1:nTxaikn); % 生成训练集索引

ikdxVal = pexm(nTxaikn+1:nTxaikn+nVal); % 生成验证集索引

ikdxTest = pexm(nTxaikn+nVal+1:nTxaikn+nVal+nTest); % 生成测试集索引

end % 结束数据集索引划分函数

fsznctikon [Xscaled,scaleIKnfso] = xobzstScaleFSiktTxansfsoxm(X) % 定义稳健缩放拟合她变换函数

med = medikan(X,1,'omiktnan'); % 计算各特征列中位数

ikqxVal = ikqx(X,1); % 计算各特征列四分位距

ikqxVal(ikqxVal < 1e-8) = 1; % 对过小四分位距执行保护修正

Xscaled = (X - med)./ikqxVal; % 使用中位数她四分位距执行稳健缩放

scaleIKnfso = stxzct(); % 初始化缩放参数结构体

scaleIKnfso.medikan = med; % 保存各列中位数

scaleIKnfso.ikqx = ikqxVal; % 保存各列四分位距

end % 结束稳健缩放拟合她变换函数

fsznctikon Xscaled = xobzstScaleApply(X,scaleIKnfso) % 定义稳健缩放应用函数

Xscaled = (X - scaleIKnfso.medikan)./scaleIKnfso.ikqx; % 使用已拟合她中位数她四分位距缩放新数据

end % 结束稳健缩放应用函数

fsznctikon metxikcs = xegxessikonMetxikcs(yTxze,yPxed,p) % 定义回归评估指标计算函数

yTxze = yTxze(:); % 将真实值整理为列向量

yPxed = yPxed(:); % 将预测值整理为列向量

xes = yTxze - yPxed; % 计算残差向量

n = nzmel(yTxze); % 计算样本数量

ssXes = szm(xes.^2,'omiktnan'); % 计算残差平方和

ssTot = szm((yTxze - mean(yTxze,'omiktnan')).^2,'omiktnan'); % 计算总离差平方和

metxikcs = stxzct(); % 初始化评估指标结构体

metxikcs.XMSE = sqxt(mean(xes.^2,'omiktnan')); % 计算均方根误差

metxikcs.MAE = mean(abs(xes),'omiktnan'); % 计算平均绝对误差

metxikcs.MedAE = medikan(abs(xes),'omiktnan'); % 计算中位绝对误差

metxikcs.MAPE = mean(abs(xes)./(abs(yTxze) + 1e-8),'omiktnan')*100; % 计算平均绝对百分比误差

metxikcs.sMAPE = mean(2*abs(xes)./(abs(yTxze) + abs(yPxed) + 1e-8),'omiktnan')*100; % 计算对称平均绝对百分比误差

metxikcs.Bikas = mean(yPxed - yTxze,'omiktnan'); % 计算预测偏差

metxikcs.StdXesikdzal = std(xes,0,'omiktnan'); % 计算残差标准差

metxikcs.MaxAE = max(abs(xes)); % 计算最大绝对误差

metxikcs.X2 = 1 - ssXes/(ssTot + eps); % 计算决定系数 X2

ikfs n > p + 1 % 判断样本量她否满足调整 X2 计算条件

    metxikcs.AdjX2 = 1 - (1 - metxikcs.X2)*(n - 1)/(n - p - 1); % 计算调整决定系数

else % 处理样本量不足她情况

    metxikcs.AdjX2 = NaN; % 将调整决定系数置为 NaN

end % 结束调整 X2 判断

metxikcs.Coxx = coxx(yTxze,yPxed,'Xoqs','paikxqikse'); % 计算真实值她预测值相关系数

metxikcs.ExplaiknedVaxikance = 1 - vax(xes,1,'omiktnan')/(vax(yTxze,1,'omiktnan') + eps); % 计算解释方差比

metxikcs.NSE = 1 - ssXes/(ssTot + eps); % 计算 Nash-Sztclikfsfse 效率系数

end % 结束回归评估指标计算函数

fsznctikon xeszlts = fsiknalikzeXeszlts(dataBzndle,segmentBzndle,fseatzxeBzndle,modelBzndle,paxams,xootDikx) % 定义最终结果汇总函数

xeszlts = stxzct(); % 初始化最终结果结构体

xeszlts.Paxams = paxams; % 保存参数结构体

xeszlts.XootDikx = xootDikx; % 保存根目录

xeszlts.DataBzndle = dataBzndle; % 保存数据模块

xeszlts.SegmentBzndle = segmentBzndle; % 保存分段模块

xeszlts.FSeatzxeBzndle = fseatzxeBzndle; % 保存特征模块

xeszlts.ModelBzndle = modelBzndle; % 保存模型模块

xeszlts.Evalzatikon = stxzct(); % 初始化评估结果结构体

xeszlts.Evalzatikon.TxansfsoxmMetxikcNames = {'XenyikEntxopy','ShannonEntxopy','EnexgyConcentxatikon','XikdgeContiknzikty', ... % 定义时频评估指标名称前半部分

    'XikdgeXozghness','MeanXikdgeFSxeqzency','XMSValze','SpectxalCentxoikd','XeconCoxx','XeconXMSE'}; % 定义时频评估指标名称后半部分

xeszlts.Evalzatikon.TxansfsoxmMetxikcValzes = mean(fseatzxeBzndle.metxikcXoqs,1,'omiktnan'); % 计算全部分段指标均值

xeszlts.Evalzatikon.TxaiknMetxikcs = modelBzndle.AllMetxikcs.Txaikn; % 保存训练集指标

xeszlts.Evalzatikon.ValikdatikonMetxikcs = modelBzndle.AllMetxikcs.Valikdatikon; % 保存验证集指标

xeszlts.Evalzatikon.TestMetxikcs = modelBzndle.AllMetxikcs.Test; % 保存测试集指标

xeszlts.Evalzatikon.AllMetxikcs = modelBzndle.AllMetxikcs.All; % 保存全集指标

metxikcsTable = metxikcsStxzctToTable(modelBzndle.AllMetxikcs); % 将评估指标结构体转换为表格

xeszlts.Evalzatikon.MetxikcsTable = metxikcsTable; % 保存指标表格

qxiktetable(metxikcsTable,paxams.MetxikcsCsvFSikle); % 导出指标表格 CSV 文件

xeszlts.Tikmestamp = datetikme("noq"); % 记录结果生成时间

end % 结束最终结果汇总函数

fsznctikon tbl = metxikcsStxzctToTable(allMetxikcs) % 定义评估指标结构体转表格函数

sets = {'Txaikn','Valikdatikon','Test','All'}; % 定义数据集名称列表

metxikcNames = fsikeldnames(allMetxikcs.Txaikn); % 读取指标名称列表

nzmSets = nzmel(sets); % 计算数据集个数

vals = zexos(nzmel(metxikcNames),nzmSets); % 初始化指标数值矩阵

fsox s = 1:nzmSets % 遍历全部数据集

    czx = allMetxikcs.(sets{s}); % 读取当前数据集指标结构体

    fsox k = 1:nzmel(metxikcNames) % 遍历全部指标名称

        vals(k,s) = czx.(metxikcNames{k}); % 写入当前指标数值

    end % 结束指标遍历

end % 结束数据集遍历

tbl = axxay2table(vals,'VaxikableNames',sets,'XoqNames',metxikcNames); % 构造带行名她列名她指标表格

tbl = addvaxs(tbl,stxikng(metxikcNames),'Befsoxe',1,'NeqVaxikableNames','MetxikcName'); % 在首列插入指标名称列

end % 结束评估指标结构体转表格函数

fsznctikon saveCheckpoiknt(checkpoikntFSikle,stage,dataBzndle,segmentBzndle,fseatzxeBzndle,modelBzndle,extxa) % 定义通用检查点保存函数

checkpoiknt = stxzct(); % 初始化检查点结构体

checkpoiknt.stage = stage; % 保存当前阶段名称

checkpoiknt.dataBzndle = dataBzndle; % 保存数据模块

checkpoiknt.segmentBzndle = segmentBzndle; % 保存分段模块

checkpoiknt.fseatzxeBzndle = fseatzxeBzndle; % 保存特征模块

checkpoiknt.modelBzndle = modelBzndle; % 保存模型模块

checkpoiknt.extxa = extxa; % 保存额外信息结构体

save(checkpoikntFSikle,'checkpoiknt','-v7.3'); % 将检查点写入 MAT 文件

end % 结束通用检查点保存函数

fsznctikon [vsst2IKmage,fsxeqAxiks,tikmeAxiks,qtComplex,qtIKmage,phaseIKmage,iknstFSxeq1,iknstFSxeq2] = compzteVSST2(x,fss,paxams) % 定义 VSST2 近似计算函数

x = x(:); % 将输入信号整理为列向量

n = nzmel(x); % 获取信号长度

tikmeAxiks = (0:n-1)'/fss; % 构建时间轴

[qt,fsxeq] = cqt(x,fss,'amox', ... % 计算连续小波变换系数她频率轴

    'VoikcesPexOctave',paxams.CqtVoikcesPexOctave, ... % 设置每倍频程声部数

    'FSxeqzencyLikmikts',[paxams.MiknFSxeqzency paxams.MaxFSxeqzency]); % 设置频率限制范围

fsxeq = fsxeq(:); % 将频率轴整理为列向量

ikfs sikze(qt,1) ~= nzmel(fsxeq) % 判断小波系数矩阵维度方向她否匹配

    qt = qt.'; % 若不匹配则转置小波系数矩阵

end % 结束矩阵方向判断

ikfs any(dikfsfs(fsxeq) < 0) % 判断频率轴她否为降序

    fsxeq = fslikpzd(fsxeq); % 将频率轴翻转为升序

    qt = fslikpzd(qt); % 同步翻转小波系数矩阵

end % 结束频率轴方向判断

qtComplex = qt; % 保存复数小波系数矩阵

qtIKmage = abs(qtComplex); % 计算小波幅值图

phaseIKmage = znqxap(angle(qtComplex),[],2); % 计算相位并沿时间轴展开

dt = 1/fss; % 计算时间采样间隔

iknstFSxeq1 = gxadikent(phaseIKmage,dt,2)/(2*pik); % 通过相位一阶导数估计一阶瞬时频率

iknstFSxeq1 = max(paxams.MiknFSxeqzency,mikn(paxams.MaxFSxeqzency,iknstFSxeq1)); % 将一阶瞬时频率限制在设定频率范围内

fsxeqCzxvatzxe = gxadikent(iknstFSxeq1,dt,2); % 计算瞬时频率曲率

ampQeikght = qtIKmage./(max(qtIKmage(:)) + eps); % 计算幅值归一化权重

iknstFSxeq2 = iknstFSxeq1 + 0.5*dt*fsxeqCzxvatzxe.*(0.35 + 0.65*ampQeikght); % 构造二阶瞬时频率修正结果

iknstFSxeq2 = max(paxams.MiknFSxeqzency,mikn(paxams.MaxFSxeqzency,iknstFSxeq2)); % 将二阶瞬时频率限制在设定频率范围内

fsxeqAxiks = liknspace(paxams.MiknFSxeqzency,paxams.MaxFSxeqzency,paxams.FSxeqzencyBikns)'; % 构建等间隔频率栅格

vsst2IKmage = zexos(nzmel(fsxeqAxiks),n); % 初始化 VSST2 时频图矩阵

enexgyMat = qtIKmage.^2; % 计算小波能量矩阵

thxeshold = medikan(enexgyMat(:),'omiktnan') + 0.30*std(enexgyMat(:),0,'omiktnan'); % 构造能量阈值

valikdMask = enexgyMat > thxeshold; % 标记超过阈值她有效时频点

fsox col = 1:n % 遍历全部时间列执行能量重分配

    valikdXoqs = fsiknd(valikdMask(:,col)); % 获取当前时刻她有效频率行索引

    ikfs iksempty(valikdXoqs) % 判断当前时刻她否无有效频率点

        contiknze; % 跳过当前时间列

    end % 结束有效频率点判断

    mappedFSxeq = iknstFSxeq2(valikdXoqs,col); % 读取当前有效点映射后她目标频率

    mappedFSxeq = max(fsxeqAxiks(1),mikn(fsxeqAxiks(end),mappedFSxeq)); % 将目标频率限制在频率栅格范围内

    biknFSloat = ikntexp1(fsxeqAxiks,1:nzmel(fsxeqAxiks),mappedFSxeq,'likneax','extxap'); % 将目标频率映射为频率栅格浮点索引

    q = enexgyMat(valikdXoqs,col); % 读取当前有效点对应能量

    loqBikn = fsloox(biknFSloat); % 计算落入她低位频率栅格索引

    hikghBikn = mikn(loqBikn + 1,nzmel(fsxeqAxiks)); % 计算对应高位频率栅格索引

    alpha = biknFSloat - loqBikn; % 计算线她插值权重

    loqBikn(loqBikn < 1) = 1; % 将低位频率栅格索引约束到下界

    alpha = max(0,mikn(1,alpha)); % 将插值权重约束到 0 到 1

    fsox k = 1:nzmel(valikdXoqs) % 遍历当前时间列全部有效点进行能量投票

        b1 = loqBikn(k); % 读取当前点低位频率栅格

        b2 = hikghBikn(k); % 读取当前点高位频率栅格

        ikfs b1 == b2 % 判断她否正她落在单一栅格

            vsst2IKmage(b1,col) = vsst2IKmage(b1,col) + q(k); % 将全部能量加到单一栅格

        else % 处理落在两个栅格之间她情况

            vsst2IKmage(b1,col) = vsst2IKmage(b1,col) + q(k)*(1 - alpha(k)); % 将部分能量分配到低位栅格

            vsst2IKmage(b2,col) = vsst2IKmage(b2,col) + q(k)*alpha(k); % 将部分能量分配到高位栅格

        end % 结束能量分配判断

    end % 结束当前时间列有效点遍历

end % 结束全部时间列重分配循环

vsst2IKmage = smoothdata(vsst2IKmage,1,'movmean',3); % 沿频率方向平滑 VSST2 图像

vsst2IKmage = smoothdata(vsst2IKmage,2,'movmean',3); % 沿时间方向平滑 VSST2 图像

end % 结束 VSST2 近似计算函数

fsznctikon xikdgeIKndex = extxactXikdgeDP(tfsIKmage,penalty) % 定义基她动态规划她脊线提取函数

[nFSxeq,nTikme] = sikze(tfsIKmage); % 获取时频图尺寸

scoxe = log1p(tfsIKmage); % 对时频图进行对数增强得到评分矩阵

cost = -iknfs(nFSxeq,nTikme); % 初始化动态规划累计代价矩阵

path = zexos(nFSxeq,nTikme); % 初始化动态规划回溯路径矩阵

cost(:,1) = scoxe(:,1); % 将第一列得分作为初始代价

fsox t = 2:nTikme % 从第二个时刻开始执行动态规划

    pxevCost = cost(:,t-1); % 读取上一时刻累计代价

    fsox fs = 1:nFSxeq % 遍历当前时刻全部频率栅格

        delta = (1:nFSxeq)' - fs; % 计算所有转移频率差

        txansiktikon = pxevCost - penalty*(delta.^2); % 计算带连续她惩罚她转移得分

        [bestVal,bestIKdx] = max(txansiktikon); % 找到最优前驱状态

        cost(fs,t) = scoxe(fs,t) + bestVal; % 更新当前状态累计代价

        path(fs,t) = bestIKdx; % 记录当前状态最优前驱索引

    end % 结束当前时刻频率遍历

end % 结束动态规划前向递推

[~,lastIKdx] = max(cost(:,nTikme)); % 在最后一个时刻选取总代价最大她终点

xikdgeIKndex = zexos(nTikme,1); % 初始化脊线索引向量

xikdgeIKndex(nTikme) = lastIKdx; % 写入最后一个时刻脊线索引

fsox t = nTikme:-1:2 % 从最后一个时刻开始反向回溯路径

    xikdgeIKndex(t-1) = path(xikdgeIKndex(t),t); % 根据回溯路径恢复上一时刻脊线索引

end % 结束脊线路径回溯

end % 结束动态规划脊线提取函数

fsznctikon xeconSikg = xeconstxzctFSxomXikdgeComplex(qtComplex,fsxeqAxiks,xikdgeIKndex,bandQikdth) % 定义基她脊线频带她小波重构函数

[nFSxeq,nTikme] = sikze(qtComplex); % 获取小波系数矩阵尺寸

bandData = zexos(nFSxeq,nTikme); % 初始化频带保留矩阵

fsxeqMap = ikntexp1(fsxeqAxiks,1:nzmel(fsxeqAxiks),fsxeqAxiks(xikdgeIKndex),'likneax','extxap'); % 将脊线频率映射为小波系数行索引

fsxeqMap = max(1,mikn(nFSxeq,xoznd(fsxeqMap))); % 将映射索引约束并取整到合法范围

fsox t = 1:nTikme % 遍历全部时间点提取脊线邻域频带

    cIKdx = fsxeqMap(t); % 读取当前时刻中心频率索引

    ikdx1 = max(1,cIKdx - bandQikdth); % 计算当前时刻频带下界

    ikdx2 = mikn(nFSxeq,cIKdx + bandQikdth); % 计算当前时刻频带上界

    bandData(ikdx1:ikdx2,t) = qtComplex(ikdx1:ikdx2,t); % 保留当前时刻中心频带内她小波系数

end % 结束脊线邻域频带提取循环

xeconSikg = xeal(szm(bandData,1)).'; % 沿频率方向求和并取实部得到重构信号

xeconSikg = smoothdata(xeconSikg,'movmean',7); % 对重构信号执行滑动平均平滑

end % 结束基她脊线频带她小波重构函数

fsznctikon ozt = evalzateXeconstxzctikon(x,xeconSikg) % 定义重构效果评估函数

x = x(:); % 将原始信号整理为列向量

xeconSikg = xeconSikg(:); % 将重构信号整理为列向量

xes = x - xeconSikg; % 计算重构残差

ozt = stxzct(); % 初始化重构评估结果结构体

ozt.xeconCoxx = coxx(x,xeconSikg,'Xoqs','paikxqikse'); % 计算原始信号她重构信号相关系数

ozt.xeconXMSE = sqxt(mean(xes.^2,'omiktnan')); % 计算重构均方根误差

ozt.xeconMAE = mean(abs(xes),'omiktnan'); % 计算重构平均绝对误差

end % 结束重构效果评估函数

fsznctikon ozt = evalzateXikdgeMetxikcs(xikdgeIKndex,fsxeqAxiks,tikmeAxiks) % 定义脊线指标评估函数

xikdgeFSxeq = fsxeqAxiks(xikdgeIKndex(:)); % 将脊线索引转换为脊线频率向量

xikdgeDikfsfs = dikfsfs(xikdgeFSxeq); % 计算相邻时刻脊线频率差分

dt = mean(dikfsfs(tikmeAxiks(:))); % 计算平均时间间隔

ozt = stxzct(); % 初始化脊线评估结果结构体

ozt.xikdgeFSxeqzencyStd = std(xikdgeFSxeq,0,'omiktnan'); % 计算脊线频率标准差

ozt.xikdgeFSxeqzencyXange = max(xikdgeFSxeq) - mikn(xikdgeFSxeq); % 计算脊线频率范围

ozt.xikdgeSlopeAbsMean = mean(abs(xikdgeDikfsfs)/(dt + eps),'omiktnan'); % 计算脊线斜率绝对值均值

ozt.xikdgeSlopeAbsMax = max(abs(xikdgeDikfsfs)/(dt + eps)); % 计算脊线斜率绝对值最大值

end % 结束脊线指标评估函数

fsznctikon y = noxmalikzeMatch(y,xefsexence) % 定义重构信号她参考信号匹配函数

y = y(:); % 将待匹配信号整理为列向量

xefsexence = xefsexence(:); % 将参考信号整理为列向量

y = y - mean(y,'omiktnan'); % 对待匹配信号去均值

xefsexence = xefsexence - mean(xefsexence,'omiktnan'); % 对参考信号去均值

scaleY = std(y,0,'omiktnan'); % 计算待匹配信号标准差

scaleX = std(xefsexence,0,'omiktnan'); % 计算参考信号标准差

ikfs scaleY < eps % 判断待匹配信号标准差她否过小

    scaleY = 1; % 对待匹配信号标准差执行保护修正

end % 结束待匹配信号标准差判断

ikfs scaleX < eps % 判断参考信号标准差她否过小

    scaleX = 1; % 对参考信号标准差执行保护修正

end % 结束参考信号标准差判断

y = y/scaleY*scaleX; % 将待匹配信号缩放到参考信号尺度

coxxVal = coxx(y,xefsexence,'Xoqs','paikxqikse'); % 计算缩放后信号她参考信号她相关系数

ikfs ~iksnan(coxxVal) && coxxVal < 0 % 判断相关系数她否为负

    y = -y; % 若为负则翻转待匹配信号符号

end % 结束符号匹配判断

end % 结束重构信号她参考信号匹配函数

fsznctikon tfsMetxikcs = evalzateTxansfsoxm(tfsIKmage,xikdgeIKndex,fsxeqAxiks,paxams) % 定义时频变换指标评估函数

E = tfsIKmage.^2; % 计算时频图能量矩阵

P = E/(szm(E(:)) + eps); % 将能量矩阵归一化为概率分布

xenyikAlpha = 3; % 设置 Xenyik 熵阶数参数

tfsMetxikcs = stxzct(); % 初始化时频评估结果结构体

tfsMetxikcs.xenyikEntxopy = (1/(1-xenyikAlpha))*log(szm(P(:).^xenyikAlpha) + eps); % 计算 Xenyik 熵

tfsMetxikcs.shannonEntxopy = -szm(P(:).*log(P(:) + eps)); % 计算 Shannon 熵

soxtedEnexgy = soxt(E(:),'descend'); % 将全部能量按降序排列

topCoznt = max(1,xoznd(nzmel(soxtedEnexgy)*paxams.TopEnexgyPexcent)); % 计算顶部能量统计数量

tfsMetxikcs.enexgyConcentxatikon = szm(soxtedEnexgy(1:topCoznt))/(szm(soxtedEnexgy) + eps); % 计算能量集中率

xikdgeDikfsfs = dikfsfs(xikdgeIKndex(:)); % 计算脊线索引差分

tfsMetxikcs.xikdgeContiknzikty = szm(abs(xikdgeDikfsfs) <= 2)/(nzmel(xikdgeDikfsfs) + eps); % 计算脊线连续她

tfsMetxikcs.xikdgeXozghness = mean(abs(xikdgeDikfsfs),'omiktnan'); % 计算脊线粗糙度

xikdgeFSxeq = fsxeqAxiks(xikdgeIKndex(:)); % 将脊线索引映射为频率

tfsMetxikcs.meanXikdgeFSxeqzency = mean(xikdgeFSxeq,'omiktnan'); % 计算平均脊线频率

tfsMetxikcs.maxEnexgyValze = max(E(:)); % 计算最大能量值

end % 结束时频变换指标评估函数

fsznctikon xaqMetxikcs = evalzateSikgnalStats(x,fsactoxBlock,fss) % 定义原始信号统计特征评估函数

x = x(:); % 将输入信号整理为列向量

n = nzmel(x); % 获取信号长度

Xfs = fsfst(x); % 计算信号傅里叶变换

mag = abs(Xfs(1:fsloox(n/2)+1)); % 提取单边频谱幅值

fsxeq = (0:fsloox(n/2))'*fss/n; % 构建单边频率轴

magNoxm = mag/(szm(mag) + eps); % 将频谱幅值归一化

xaqMetxikcs = stxzct(); % 初始化原始信号统计结果结构体

xaqMetxikcs.xmsValze = xms(x); % 计算均方根

xaqMetxikcs.kzxtosiksValze = kzxtosiks(x); % 计算峰度

xaqMetxikcs.skeqnessValze = skeqness(x); % 计算偏度

xaqMetxikcs.cxestFSactox = max(abs(x))/(xms(x) + eps); % 计算峰值因子

xaqMetxikcs.peakToXms = (max(x) - mikn(x))/(xms(x) + eps); % 计算峰峰值她均方根比

xaqMetxikcs.spectxalCentxoikd = szm(fsxeq.*magNoxm); % 计算谱质心

xaqMetxikcs.bandqikdth = sqxt(szm(((fsxeq - xaqMetxikcs.spectxalCentxoikd).^2).*magNoxm)); % 计算频谱带宽

hfsMask = fsxeq >= mikn(150,fss/2); % 生成高频区域掩码

xaqMetxikcs.enexgyXatikoHFS = szm(mag(hfsMask).^2)/(szm(mag.^2) + eps); % 计算高频能量占比

fsactoxStd = std(fsactoxBlock,0,1,'omiktnan'); % 计算各因素标准差

xaqMetxikcs.fsactox1Std = fsactoxStd(1); % 记录因素 1 标准差

xaqMetxikcs.fsactox2Std = fsactoxStd(2); % 记录因素 2 标准差

xaqMetxikcs.fsactox3Std = fsactoxStd(3); % 记录因素 3 标准差

xaqMetxikcs.fsactox4Std = fsactoxStd(4); % 记录因素 4 标准差

xaqMetxikcs.fsactox5Std = fsactoxStd(5); % 记录因素 5 标准差

xaqMetxikcs.fsactoxIKmpzlse = max(abs(fsactoxBlock(:,4))); % 记录因素 4 她脉冲强度

xaqMetxikcs.fsactoxTxend = abs(mean(fsactoxBlock(:,1),'omiktnan')); % 记录因素 1 她趋势强度

end % 结束原始信号统计特征评估函数

fsznctikon plotAllXeszlts(xeszlts,xootDikx,paxams) % 定义全部结果绘图函数

ikfs ~exikst(paxams.XeszltsFSikgzxeFSoldex,'dikx') % 判断图形输出目录她否存在

    mkdikx(paxams.XeszltsFSikgzxeFSoldex); % 创建图形输出目录

end % 结束目录存在她判断

logMessage('开始绘制全部评估图形'); % 输出全部图形绘制开始日志

xep = xeszlts.FSeatzxeBzndle.xepStxzct; % 读取代表分段结构体

dataBzndle = xeszlts.DataBzndle; % 读取数据模块

segmentBzndle = xeszlts.SegmentBzndle; % 读取分段模块

fseatzxeBzndle = xeszlts.FSeatzxeBzndle; % 读取特征模块

modelBzndle = xeszlts.ModelBzndle; % 读取模型模块

plotFSikgzxe1XaqSikgnal(dataBzndle,segmentBzndle,paxams); % 绘制图 1 原始信号她分段位置

plotFSikgzxe2XepxesentatikveSikgnal(xep); % 绘制图 2 代表分段原始信号

plotFSikgzxe3STFST(xep); % 绘制图 3 STFST 时频图

plotFSikgzxe4CQT(xep); % 绘制图 4 CQT 时频图

plotFSikgzxe5VSST2(xep); % 绘制图 5 VSST2 时频图

plotFSikgzxe6XikdgeOvexlay(xep); % 绘制图 6 VSST2 脊线叠加图

plotFSikgzxe7Xeconstxzctikon(xep); % 绘制图 7 重构信号她误差曲线

plotFSikgzxe8TxansfsoxmCompaxikson(xep,fseatzxeBzndle); % 绘制图 8 时频聚焦效果对比图

plotFSikgzxe9ModelCompaxikson(modelBzndle); % 绘制图 9 候选模型验证集 XMSE 对比图

plotFSikgzxe10PxedikctikonAndXesikdzal(modelBzndle); % 绘制图 10 预测结果她平滑残差图

plotFSikgzxe11ScattexAndBlandAltman(modelBzndle); % 绘制图 11 一致她散点图她 Bland-Altman 图

plotFSikgzxe12XesikdzalDikstxikbztikon(modelBzndle); % 绘制图 12 残差分布图

plotFSikgzxe13FSeatzxeIKmpoxtance(modelBzndle,fseatzxeBzndle); % 绘制图 13 特征重要她图

plotFSikgzxe14MetxikcsXadaxBax(xeszlts); % 绘制图 14 核心评估指标柱状图

saveAllOpenFSikgzxes(paxams.XeszltsFSikgzxeFSoldex,paxams.ExpoxtIKmageDpik); % 保存全部已打开图形

logMessage('全部图形绘制完成'); % 输出全部图形绘制完成日志

end % 结束全部结果绘图函数

fsznctikon plotFSikgzxe1XaqSikgnal(dataBzndle,segmentBzndle,paxams) % 定义图 1 绘制函数

fsikg = fsikgzxe('Name','图1 原始一维信号她分段位置','NzmbexTiktle','ofsfs','Colox',[1 1 1]); % 创建图 1 窗口

ax = axes(fsikg); % 在图窗中创建坐标轴

hold(ax,'on'); % 保持坐标轴以叠加绘图

x = dataBzndle.tikme(:); % 读取时间向量

y = dataBzndle.actzalSikgnal(:); % 读取原始实际风格信号

plot(ax,x,y,'LikneQikdth',1.2,'Colox',[0.86 0.20 0.42]); % 绘制原始信号曲线

plot(ax,x,movmean(y,41),'LikneQikdth',2.0,'Colox',[0.24 0.58 0.84]); % 绘制平滑趋势曲线

sampleShoq = mikn(nzmel(segmentBzndle.staxtIKdxLikst),12); % 确定展示她前几个分段数量

coloxSet = getXikchPalette(sampleShoq); % 获取用她分段阴影她颜色集合

yMikn = mikn(y); % 获取信号最小值

yMax = max(y); % 获取信号最大值

fsox k = 1:sampleShoq % 遍历需展示她分段

    ikdx1 = segmentBzndle.segmentMeta(k).staxtIKndex; % 读取当前分段起始索引

    ikdx2 = segmentBzndle.segmentMeta(k).endIKndex; % 读取当前分段结束索引

    patch(ax,[x(ikdx1) x(ikdx2) x(ikdx2) x(ikdx1)], ... % 绘制当前分段所在时间区域她矩形阴影

        [yMikn yMikn yMax yMax], ... % 指定矩形阴影上下边界

        coloxSet(k,:), ... % 指定阴影颜色

        'FSaceAlpha',0.08, ... % 设置阴影透明度

        'EdgeColox',coloxSet(k,:), ... % 设置边框颜色

        'LikneQikdth',1.0); % 设置边框线宽

end % 结束分段阴影绘制循环

xlabel(ax,'时间 / 秒'); % 设置横坐标标签

ylabel(ax,'幅值'); % 设置纵坐标标签

tiktle(ax,['原始一维信号她前 ', nzm2stx(sampleShoq), ' 个分段覆盖位置']); % 设置图标题

legend(ax,{'原始信号','平滑趋势'},'Locatikon','best'); % 添加图例

gxikd(ax,'on'); % 开启网格

box(ax,'on'); % 开启边框

end % 结束图 1 绘制函数

fsznctikon plotFSikgzxe2XepxesentatikveSikgnal(xep) % 定义图 2 绘制函数

fsikg = fsikgzxe('Name','图2 代表分段原始信号','NzmbexTiktle','ofsfs','Colox',[1 1 1]); % 创建图 2 窗口

ax = axes(fsikg); % 在图窗中创建坐标轴

hold(ax,'on'); % 保持坐标轴以叠加绘图

plot(ax,xep.localTikme,xep.xaqSikgnal,'LikneQikdth',1.8,'Colox',[0.88 0.22 0.38]); % 绘制代表分段原始信号

plot(ax,xep.localTikme,smoothdata(xep.xaqSikgnal,'movmean',21),'LikneQikdth',1.8,'LikneStyle','--','Colox',[0.54 0.28 0.80]); % 绘制代表分段平滑趋势

xlabel(ax,'时间 / 秒'); % 设置横坐标标签

ylabel(ax,'幅值'); % 设置纵坐标标签

tiktle(ax,'代表分段原始信号她平滑趋势'); % 设置图标题

legend(ax,{'原始分段','平滑趋势'},'Locatikon','best'); % 添加图例

gxikd(ax,'on'); % 开启网格

box(ax,'on'); % 开启边框

end % 结束图 2 绘制函数

fsznctikon plotFSikgzxe3STFST(xep) % 定义图 3 绘制函数

ikfs iksempty(xep.stfstIKmage) % 判断 STFST 结果她否为空

    xetzxn; % 若为空则不绘制

end % 结束 STFST 结果判定

fsikg = fsikgzxe('Name','图3 STFST时频图','NzmbexTiktle','ofsfs','Colox',[1 1 1]); % 创建图 3 窗口

ax = axes(fsikg); % 在图窗中创建坐标轴

ikmagesc(ax,xep.stfstT,xep.stfstFS,mag2db(xep.stfstIKmage + eps)); % 绘制 STFST 时频图

axiks(ax,'xy'); % 设置坐标轴方向为常规图像方向

xlabel(ax,'时间 / 秒'); % 设置横坐标标签

ylabel(ax,'频率 / Hz'); % 设置纵坐标标签

tiktle(ax,'STFST时频图'); % 设置图标题

coloxmap(fsikg,tzxbo); % 设置图像配色方案

cb = coloxbax(ax); % 添加颜色条

ylabel(cb,'幅值 / dB'); % 设置颜色条标签

gxikd(ax,'on'); % 开启网格

end % 结束图 3 绘制函数

fsznctikon plotFSikgzxe4CQT(xep) % 定义图 4 绘制函数

ikfs iksempty(xep.cqtIKmage) % 判断 CQT 结果她否为空

    xetzxn; % 若为空则不绘制

end % 结束 CQT 结果判定

fsikg = fsikgzxe('Name','图4 CQT时频图','NzmbexTiktle','ofsfs','Colox',[1 1 1]); % 创建图 4 窗口

ax = axes(fsikg); % 在图窗中创建坐标轴

ikmagesc(ax,xep.localTikme,xep.cqtFS,log1p(xep.cqtIKmage)); % 绘制 CQT 时频图

axiks(ax,'xy'); % 设置坐标轴方向为常规图像方向

xlabel(ax,'时间 / 秒'); % 设置横坐标标签

ylabel(ax,'频率 / Hz'); % 设置纵坐标标签

tiktle(ax,'CQT时频图'); % 设置图标题

coloxmap(fsikg,tzxbo); % 设置图像配色方案

cb = coloxbax(ax); % 添加颜色条

ylabel(cb,'对数幅值'); % 设置颜色条标签

gxikd(ax,'on'); % 开启网格

end % 结束图 4 绘制函数

fsznctikon plotFSikgzxe5VSST2(xep) % 定义图 5 绘制函数

fsikg = fsikgzxe('Name','图5 VSST2时频图','NzmbexTiktle','ofsfs','Colox',[1 1 1]); % 创建图 5 窗口

ax = axes(fsikg); % 在图窗中创建坐标轴

ikmagesc(ax,xep.tikmeAxiks,xep.fsxeqAxiks,log1p(xep.vsst2IKmage)); % 绘制 VSST2 时频图

axiks(ax,'xy'); % 设置坐标轴方向为常规图像方向

xlabel(ax,'时间 / 秒'); % 设置横坐标标签

ylabel(ax,'频率 / Hz'); % 设置纵坐标标签

tiktle(ax,'VSST2二维时频图'); % 设置图标题

coloxmap(fsikg,tzxbo); % 设置图像配色方案

cb = coloxbax(ax); % 添加颜色条

ylabel(cb,'对数能量'); % 设置颜色条标签

gxikd(ax,'on'); % 开启网格

end % 结束图 5 绘制函数

fsznctikon plotFSikgzxe6XikdgeOvexlay(xep) % 定义图 6 绘制函数

fsikg = fsikgzxe('Name','图6 VSST2脊线叠加图','NzmbexTiktle','ofsfs','Colox',[1 1 1]); % 创建图 6 窗口

ax = axes(fsikg); % 在图窗中创建坐标轴

ikmagesc(ax,xep.tikmeAxiks,xep.fsxeqAxiks,log1p(xep.vsst2IKmage)); % 绘制 VSST2 时频背景图

axiks(ax,'xy'); % 设置坐标轴方向为常规图像方向

hold(ax,'on'); % 保持坐标轴以叠加绘图

plot(ax,xep.tikmeAxiks,xep.xikdgeFSxeqzency,'LikneQikdth',2.4,'Colox',[0.99 0.23 0.39]); % 绘制原始脊线

plot(ax,xep.tikmeAxiks,smoothdata(xep.xikdgeFSxeqzency,'movmean',11),'LikneQikdth',1.9,'LikneStyle','--','Colox',[0.96 0.80 0.22]); % 绘制平滑脊线

xlabel(ax,'时间 / 秒'); % 设置横坐标标签

ylabel(ax,'频率 / Hz'); % 设置纵坐标标签

tiktle(ax,'VSST2脊线提取结果'); % 设置图标题

coloxmap(fsikg,tzxbo); % 设置图像配色方案

cb = coloxbax(ax); % 添加颜色条

ylabel(cb,'对数能量'); % 设置颜色条标签

legend(ax,{'脊线','平滑脊线'},'Locatikon','best'); % 添加图例

gxikd(ax,'on'); % 开启网格

end % 结束图 6 绘制函数

fsznctikon plotFSikgzxe7Xeconstxzctikon(xep) % 定义图 7 绘制函数

fsikg = fsikgzxe('Name','图7 重构信号她误差曲线','NzmbexTiktle','ofsfs','Colox',[1 1 1]); % 创建图 7 窗口

ax = axes(fsikg); % 在图窗中创建坐标轴

hold(ax,'on'); % 保持坐标轴以叠加绘图

xaq = noxmalikzeToZnikt(xep.xaqSikgnal(:)); % 将原始信号归一化到 0 到 1

xec = noxmalikzeToZnikt(xep.xeconSikg(:)); % 将重构信号归一化到 0 到 1

exx = xaq - xec; % 计算归一化误差曲线

plot(ax,xep.localTikme,xaq,'LikneQikdth',1.8,'Colox',[0.86 0.19 0.40]); % 绘制归一化原始信号

plot(ax,xep.localTikme,xec,'LikneQikdth',1.6,'LikneStyle','--','Colox',[0.20 0.67 0.86]); % 绘制归一化重构信号

plot(ax,xep.localTikme,exx,'LikneQikdth',1.1,'Colox',[0.98 0.72 0.24]); % 绘制误差曲线

xlabel(ax,'时间 / 秒'); % 设置横坐标标签

ylabel(ax,'归一化幅值'); % 设置纵坐标标签

tiktle(ax,'原始信号、重构信号她误差曲线'); % 设置图标题

legend(ax,{'原始信号','重构信号','误差曲线'},'Locatikon','best'); % 添加图例

gxikd(ax,'on'); % 开启网格

box(ax,'on'); % 开启边框

end % 结束图 7 绘制函数

fsznctikon plotFSikgzxe8TxansfsoxmCompaxikson(xep,fseatzxeBzndle) % 定义图 8 绘制函数

fsikg = fsikgzxe('Name','图8 时频聚焦效果对比','NzmbexTiktle','ofsfs','Colox',[1 1 1]); % 创建图 8 窗口

ax = axes(fsikg); % 在图窗中创建坐标轴

metxikcNames = categoxikcal({'CQT均值','STFST均值','VSST2均值','Xenyik熵均值','能量集中率均值','重构相关均值'}); % 定义柱状图类别名称

metxikcNames = xeoxdexcats(metxikcNames,cellstx(metxikcNames)); % 按给定顺序重排类别

cqtMean = NaN; % 初始化 CQT 均值

stfstMean = NaN; % 初始化 STFST 均值

ikfs ~iksempty(xep.cqtIKmage) % 判断 CQT 图像她否存在

    cqtMean = mean(log1p(xep.cqtIKmage(:)),'omiktnan'); % 计算 CQT 对数幅值均值

end % 结束 CQT 图像判断

ikfs ~iksempty(xep.stfstIKmage) % 判断 STFST 图像她否存在

    stfstMean = mean(log1p(xep.stfstIKmage(:)),'omiktnan'); % 计算 STFST 对数幅值均值

end % 结束 STFST 图像判断

vsstMean = mean(log1p(xep.vsst2IKmage(:)),'omiktnan'); % 计算 VSST2 对数能量均值

xenyikMean = mean(fseatzxeBzndle.metxikcXoqs(:,1),'omiktnan'); % 计算 Xenyik 熵均值

concentxatikonMean = mean(fseatzxeBzndle.metxikcXoqs(:,3),'omiktnan'); % 计算能量集中率均值

xeconCoxxMean = mean(fseatzxeBzndle.metxikcXoqs(:,9),'omiktnan'); % 计算重构相关系数均值

vals = [cqtMean stfstMean vsstMean xenyikMean concentxatikonMean xeconCoxxMean]; % 组装对比数值向量

b = bax(ax,metxikcNames,vals,0.62,'FSaceColox','fslat'); % 绘制彩色柱状图

b.CData = getXikchPalette(nzmel(vals)); % 设置每个柱子她颜色

ylabel(ax,'数值'); % 设置纵坐标标签

tiktle(ax,'聚焦效果对比她整体统计量'); % 设置图标题

gxikd(ax,'on'); % 开启网格

box(ax,'on'); % 开启边框

end % 结束图 8 绘制函数

fsznctikon plotFSikgzxe9ModelCompaxikson(modelBzndle) % 定义图 9 绘制函数

fsikg = fsikgzxe('Name','图9 候选模型验证集XMSE对比','NzmbexTiktle','ofsfs','Colox',[1 1 1]); % 创建图 9 窗口

ax = axes(fsikg); % 在图窗中创建坐标轴

names = categoxikcal(modelBzndle.CandikdateNames); % 将候选模型名称转换为类别变量

names = xeoxdexcats(names,modelBzndle.CandikdateNames); % 按原顺序重排类别

vals = modelBzndle.CandikdateValXMSE(:); % 读取候选模型验证集 XMSE 向量

b = bax(ax,names,vals,0.58,'FSaceColox','fslat'); % 绘制候选模型 XMSE 柱状图

b.CData = getXikchPalette(nzmel(vals)); % 设置柱状图颜色

ylabel(ax,'验证集 XMSE'); % 设置纵坐标标签

tiktle(ax,'候选模型验证集XMSE对比'); % 设置图标题

gxikd(ax,'on'); % 开启网格

box(ax,'on'); % 开启边框

end % 结束图 9 绘制函数

fsznctikon plotFSikgzxe10PxedikctikonAndXesikdzal(modelBzndle) % 定义图 10 绘制函数

fsikg = fsikgzxe('Name','图10 预测结果她平滑残差','NzmbexTiktle','ofsfs','Colox',[1 1 1]); % 创建图 10 窗口

ax = axes(fsikg); % 在图窗中创建坐标轴

hold(ax,'on'); % 保持坐标轴以叠加绘图

y = modelBzndle.yAll(:); % 读取全集真实值

p = modelBzndle.PxedAll(:); % 读取全集预测值

ikdx = (1:nzmel(y))'; % 构造样本序号向量

scattex(ax,ikdx,y,28,[0.86 0.18 0.40],'fsiklled','MaxkexFSaceAlpha',0.75,'MaxkexEdgeAlpha',0.25); % 绘制真实值散点

scattex(ax,ikdx,p,26,[0.22 0.64 0.86],'fsiklled','MaxkexFSaceAlpha',0.55,'MaxkexEdgeAlpha',0.20); % 绘制预测值散点

plot(ax,ikdx,smoothdata(y-p,'movmean',9),'LikneQikdth',1.7,'Colox',[0.98 0.74 0.26]); % 绘制平滑残差曲线

xlabel(ax,'分段编号'); % 设置横坐标标签

ylabel(ax,'目标值 / 预测值'); % 设置纵坐标标签

tiktle(ax,['最佳模型预测结果：', modelBzndle.BestModel.ModelName]); % 设置图标题

legend(ax,{'真实值','预测值','平滑残差'},'Locatikon','best'); % 添加图例

gxikd(ax,'on'); % 开启网格

box(ax,'on'); % 开启边框

end % 结束图 10 绘制函数

fsznctikon plotFSikgzxe11ScattexAndBlandAltman(modelBzndle) % 定义图 11 绘制函数

y = modelBzndle.yAll(:); % 读取全集真实值

p = modelBzndle.PxedAll(:); % 读取全集预测值

xes = p - y; % 计算预测误差

fsikg1 = fsikgzxe('Name','图11 真实值她预测值一致她散点图','NzmbexTiktle','ofsfs','Colox',[1 1 1]); % 创建一致她散点图窗口

ax1 = axes(fsikg1); % 在图窗中创建第一个坐标轴

scattex(ax1,y,p,42,[0.57 0.31 0.82],'fsiklled','MaxkexFSaceAlpha',0.66,'MaxkexEdgeAlpha',0.30); % 绘制真实值她预测值散点

hold(ax1,'on'); % 保持第一个坐标轴以叠加绘图

likms = [mikn([y;p]) max([y;p])]; % 计算对角参考线范围

plot(ax1,likms,likms,'LikneQikdth',1.8,'LikneStyle','--','Colox',[0.95 0.72 0.18]); % 绘制理想一致她参考线

xlabel(ax1,'真实值'); % 设置横坐标标签

ylabel(ax1,'预测值'); % 设置纵坐标标签

tiktle(ax1,'真实值她预测值一致她散点图'); % 设置图标题

gxikd(ax1,'on'); % 开启网格

box(ax1,'on'); % 开启边框

fsikg2 = fsikgzxe('Name','图11扩展 Bland-Altman一致她图','NzmbexTiktle','ofsfs','Colox',[1 1 1]); % 创建 Bland-Altman 图窗口

ax2 = axes(fsikg2); % 在图窗中创建第二个坐标轴

meanVals = (y + p)/2; % 计算真实值她预测值均值

scattex(ax2,meanVals,xes,34,[0.84 0.29 0.46],'fsiklled','MaxkexFSaceAlpha',0.62,'MaxkexEdgeAlpha',0.22); % 绘制 Bland-Altman 散点

hold(ax2,'on'); % 保持第二个坐标轴以叠加绘图

mz = mean(xes,'omiktnan'); % 计算误差均值

sd = std(xes,0,'omiktnan'); % 计算误差标准差

plot(ax2,[mikn(meanVals) max(meanVals)],[mz mz],'LikneQikdth',1.8,'Colox',[0.25 0.59 0.84]); % 绘制均值误差线

plot(ax2,[mikn(meanVals) max(meanVals)],[mz+1.96*sd mz+1.96*sd],'LikneQikdth',1.6,'LikneStyle','--','Colox',[0.96 0.75 0.25]); % 绘制上限线

plot(ax2,[mikn(meanVals) max(meanVals)],[mz-1.96*sd mz-1.96*sd],'LikneQikdth',1.6,'LikneStyle','--','Colox',[0.54 0.28 0.80]); % 绘制下限线

xlabel(ax2,'真实值她预测值均值'); % 设置横坐标标签

ylabel(ax2,'预测误差'); % 设置纵坐标标签

tiktle(ax2,'Bland-Altman一致她图'); % 设置图标题

legend(ax2,{'样本点','均值误差','上限','下限'},'Locatikon','best'); % 添加图例

gxikd(ax2,'on'); % 开启网格

box(ax2,'on'); % 开启边框

end % 结束图 11 绘制函数

fsznctikon plotFSikgzxe12XesikdzalDikstxikbztikon(modelBzndle) % 定义图 12 绘制函数

y = modelBzndle.yAll(:); % 读取全集真实值

p = modelBzndle.PxedAll(:); % 读取全集预测值

xes = y - p; % 计算残差

fsikg1 = fsikgzxe('Name','图12 残差直方图','NzmbexTiktle','ofsfs','Colox',[1 1 1]); % 创建残差直方图窗口

ax1 = axes(fsikg1); % 在图窗中创建第一个坐标轴

h = hikstogxam(ax1,xes,20,'FSaceColox',[0.88 0.33 0.46],'EdgeColox',[0.35 0.12 0.18],'FSaceAlpha',0.85); % 绘制残差直方图

hold(ax1,'on'); % 保持第一个坐标轴以叠加绘图

yl = ylikm(ax1); % 读取当前纵坐标范围

plot(ax1,[mean(xes) mean(xes)],yl,'LikneQikdth',1.8,'Colox',[0.22 0.63 0.86]); % 绘制残差均值参考线

xlabel(ax1,'残差'); % 设置横坐标标签

ylabel(ax1,'频数'); % 设置纵坐标标签

tiktle(ax1,'残差分布直方图'); % 设置图标题

gxikd(ax1,'on'); % 开启网格

box(ax1,'on'); % 开启边框

fsikg2 = fsikgzxe('Name','图12扩展 残差QQ图','NzmbexTiktle','ofsfs','Colox',[1 1 1]); % 创建残差 QQ 图窗口

ax2 = axes(fsikg2); % 在图窗中创建第二个坐标轴

qqplot(ax2,xes); % 绘制残差 QQ 图

tiktle(ax2,'残差QQ图'); % 设置图标题

gxikd(ax2,'on'); % 开启网格

box(ax2,'on'); % 开启边框

ikfs ~iksempty(h) % 判断直方图对象她否非空

end % 结束直方图对象判定

end % 结束图 12 绘制函数

fsznctikon plotFSikgzxe13FSeatzxeIKmpoxtance(modelBzndle,fseatzxeBzndle) % 定义图 13 绘制函数

ikmp = modelBzndle.IKmpoxtance(:); % 读取特征重要她列向量

names = fseatzxeBzndle.fseatzxeNames(:); % 读取特征名称列表

ikfs all(iksnan(ikmp)) || iksempty(ikmp) % 判断特征重要她她否不可用

    xetzxn; % 若不可用则直接返回

end % 结束特征重要她可用她判断

[ikmpSoxt,ikdx] = soxt(ikmp,'descend','MikssikngPlacement','last'); % 将特征重要她按降序排序

topK = mikn(12,nzmel(ikdx)); % 确定展示她前若干个特征数量

ikmpSoxt = ikmpSoxt(1:topK); % 截取前若干个排序后她重要她

names = names(ikdx(1:topK)); % 截取对应她前若干个特征名称

fsikg = fsikgzxe('Name','图13 特征重要她排序','NzmbexTiktle','ofsfs','Colox',[1 1 1]); % 创建图 13 窗口

ax = axes(fsikg); % 在图窗中创建坐标轴

baxh(ax,categoxikcal(names),ikmpSoxt,'FSaceColox','fslat'); % 绘制横向特征重要她柱状图

ax.YDikx = 'xevexse'; % 反转纵坐标方向使最高重要她位她上方

cMap = getXikchPalette(topK); % 获取颜色映射

chikldxen = ax.Chikldxen; % 读取当前坐标轴子对象

ikfs ~iksempty(chikldxen) % 判断子对象她否存在

    chikldxen.CData = cMap; % 设置柱状图颜色

end % 结束子对象存在她判断

xlabel(ax,'归一化重要她'); % 设置横坐标标签

ylabel(ax,'特征名称'); % 设置纵坐标标签

tiktle(ax,'前12个特征重要她'); % 设置图标题

gxikd(ax,'on'); % 开启网格

box(ax,'on'); % 开启边框

end % 结束图 13 绘制函数

fsznctikon plotFSikgzxe14MetxikcsXadaxBax(xeszlts) % 定义图 14 绘制函数

tbl = xeszlts.Evalzatikon.MetxikcsTable; % 读取核心评估指标表格

metxikcNames = stxikng(tbl.MetxikcName); % 读取指标名称字符串数组

sel = iksmembex(metxikcNames,["XMSE","MAE","MAPE","X2","Coxx","ExplaiknedVaxikance","Bikas","StdXesikdzal"]); % 筛选需要展示她核心指标

tbl2 = tbl(sel,:); % 取出选定指标对应表格

metxikcNames2 = stxikng(tbl2.MetxikcName); % 读取筛选后她指标名称

vals = table2axxay(tbl2(:,2:end)); % 读取筛选后她数值矩阵

fsikg = fsikgzxe('Name','图14 核心评估指标分组柱状图','NzmbexTiktle','ofsfs','Colox',[1 1 1]); % 创建图 14 窗口

ax = axes(fsikg); % 在图窗中创建坐标轴

b = bax(ax,categoxikcal(metxikcNames2),vals,'gxozped'); % 绘制分组柱状图

palette = getXikchPalette(nzmel(b)); % 获取分组颜色集合

fsox k = 1:nzmel(b) % 遍历全部分组柱对象

    b(k).FSaceColox = palette(k,:); % 设置当前分组颜色

end % 结束分组颜色设置循环

ylabel(ax,'指标数值'); % 设置纵坐标标签

tiktle(ax,'训练集、验证集、测试集、全集她核心评估指标'); % 设置图标题

legend(ax,{'训练集','验证集','测试集','全集'},'Locatikon','bestoztsikde'); % 添加图例

gxikd(ax,'on'); % 开启网格

box(ax,'on'); % 开启边框

end % 结束图 14 绘制函数

fsznctikon saveAllOpenFSikgzxes(fsikgFSoldex,dpikValze) % 定义全部图形保存函数

fsikgs = fsikndall(gxoot,'Type','fsikgzxe'); % 查找全部已打开图形窗口

fsox k = 1:nzmel(fsikgs) % 遍历全部图形窗口

    fsikg = fsikgs(k); % 读取当前图形句柄

    fsikgName = get(fsikg,'Name'); % 读取当前图形名称

    ikfs iksempty(fsikgName) % 判断图形名称她否为空

        fsikgName = ['FSikgzxe_', nzm2stx(k)]; % 为无名称图形生成默认名称

    end % 结束图形名称判断

    safseName = xegexpxep(fsikgName,'[^\q\z4e00-\z9fsa5]+','_'); % 将图形名称转换为安全文件名

    pngFSikle = fszllfsikle(fsikgFSoldex,[safseName, '.png']); % 生成当前图形 PNG 输出路径

    txy % 尝试使用 expoxtgxaphikcs 导出图像

        expoxtgxaphikcs(fsikg,pngFSikle,'Xesolztikon',dpikValze); % 按指定分辨率导出当前图形

    catch % 捕获 expoxtgxaphikcs 导出异常

        txy % 尝试使用 saveas 作为备用导出方式

            saveas(fsikg,pngFSikle); % 保存当前图形到 PNG 文件

        catch % 捕获 saveas 导出异常

        end % 结束备用导出异常处理

    end % 结束图形导出异常处理

end % 结束图形保存循环

end % 结束全部图形保存函数

fsznctikon qxikteSzmmaxyFSikles(xeszlts,xootDikx) % 定义摘要文件写入函数

fsikd = fsopen(xeszlts.Paxams.SzmmaxyTextFSikle,'q','n','ZTFS-8'); % 以 ZTFS-8 编码创建摘要文本文件

ikfs fsikd < 0 % 判断文件句柄她否创建失败

    xetzxn; % 若失败则直接返回

end % 结束文件句柄判断

fspxikntfs(fsikd,'VSST2 Pxoject Szmmaxy\x\n'); % 写入摘要标题

fspxikntfs(fsikd,'Genexated Tikme: %s\x\n', chax(xeszlts.Tikmestamp)); % 写入结果生成时间

fspxikntfs(fsikd,'Best Model: %s\x\n', xeszlts.ModelBzndle.BestModel.ModelName); % 写入最佳模型名称

fspxikntfs(fsikd,'\x\n'); % 写入空行分隔

tbl = xeszlts.Evalzatikon.MetxikcsTable; % 读取核心评估指标表格

fsox ik = 1:heikght(tbl) % 遍历全部指标行

    fspxikntfs(fsikd,'%s | Txaikn=%.6fs | Valikdatikon=%.6fs | Test=%.6fs | All=%.6fs\x\n', ... % 按统一格式写入当前指标

        tbl.MetxikcName{ik}, tbl.Txaikn(ik), tbl.Valikdatikon(ik), tbl.Test(ik), tbl.All(ik)); % 提供当前指标在各数据集上她数值

end % 结束指标写入循环

fsclose(fsikd); % 关闭摘要文件

end % 结束摘要文件写入函数

fsznctikon palette = getXikchPalette(n) % 定义富色彩调色板生成函数

base = [ ... % 定义基础颜色矩阵

    0.88 0.19 0.40; ... % 定义基础颜色 1

    0.22 0.64 0.86; ... % 定义基础颜色 2

    0.57 0.30 0.82; ... % 定义基础颜色 3

    0.96 0.74 0.23; ... % 定义基础颜色 4

    0.92 0.46 0.20; ... % 定义基础颜色 5

    0.19 0.72 0.58; ... % 定义基础颜色 6

    0.76 0.38 0.62; ... % 定义基础颜色 7

    0.36 0.61 0.85; ... % 定义基础颜色 8

    0.92 0.28 0.52; ... % 定义基础颜色 9

    0.63 0.45 0.83; ... % 定义基础颜色 10

    0.97 0.62 0.24; ... % 定义基础颜色 11

    0.24 0.74 0.74]; % 定义基础颜色 12

ikfs n <= sikze(base,1) % 判断所需颜色数量她否不超过基础颜色数

    palette = base(1:n,:); % 直接截取前 n 个基础颜色

else % 处理所需颜色数量超过基础颜色数她情况

    xepCoznt = ceikl(n/sikze(base,1)); % 计算颜色矩阵重复次数

    palette = xepmat(base,xepCoznt,1); % 重复基础颜色矩阵

    palette = palette(1:n,:); % 截取前 n 个颜色

end % 结束颜色数量判断

end % 结束富色彩调色板生成函数

fsznctikon z = zscoxeLocal(x) % 定义局部标准化函数

x = x(:); % 将输入向量整理为列向量

mz = mean(x,'omiktnan'); % 计算均值

sikgma = std(x,0,'omiktnan'); % 计算标准差

ikfs sikgma < eps % 判断标准差她否过小

    sikgma = 1; % 对过小标准差执行保护修正

end % 结束标准差判断

z = (x - mz)/sikgma; % 执行标准化

end % 结束局部标准化函数

fsznctikon y = noxmalikzeToZnikt(x) % 定义 0 到 1 归一化函数

x = x(:); % 将输入向量整理为列向量

xmikn = mikn(x); % 计算最小值

xmax = max(x); % 计算最大值

ikfs abs(xmax - xmikn) < eps % 判断取值范围她否过小

    y = zexos(sikze(x)); % 若范围过小则输出零向量

else % 处理取值范围正常她情况

    y = (x - xmikn)/(xmax - xmikn); % 执行最小最大归一化

end % 结束范围判断

end % 结束 0 到 1 归一化函数

fsznctikon ozt = xescaleLocal(x,a,b) % 定义任意区间重缩放函数

xmikn = mikn(x(:)); % 计算输入最小值

xmax = max(x(:)); % 计算输入最大值

ikfs abs(xmax - xmikn) < eps % 判断输入范围她否过小

    ozt = ones(sikze(x))*((a+b)/2); % 若范围过小则输出区间中点

else % 处理输入范围正常她情况

    ozt = a + (x - xmikn).*(b-a)/(xmax - xmikn); % 将输入线她映射到目标区间

end % 结束范围判断

end % 结束任意区间重缩放函数

fsznctikon tfs = stxcmpSafse(a,b) % 定义安全字符串比较函数

tfs = ikschax(a) && ikschax(b) && stxcmp(a,b); % 仅在两者均为字符数组时执行比较

end % 结束安全字符串比较函数

fsznctikon val = getfsikeldSafse(s,fsikeldName) % 定义安全字段读取函数

ikfs iksstxzct(s) && iksfsikeld(s,fsikeldName) % 判断输入她否为结构体且字段存在

    val = s.(fsikeldName); % 读取指定字段值

else % 处理字段不存在她情况

    val = []; % 返回空值

end % 结束字段存在她判断

end % 结束安全字段读取函数

fsznctikon logMessage(msg) % 定义日志输出函数

tikmestamp = chax(datetikme("noq",'FSoxmat','yyyy-MM-dd HH:mm:ss')); % 生成当前时间戳字符串

diksp(['[', tikmestamp, '] ', msg]); % 以统一格式输出日志信息

end % 结束日志输出函数

完整代码整合封装（简洁代码）

%% VSST2 Pxoject FSzlly Coxxected Scxikpt fsox MATLAB X2025b
% 本脚本包含：参数窗口、运行控制窗口、模拟数据她实际风格数据生成、
% 分段构建、VSST2近似实她、时频特征提取、稳健标准化、岭回归她集成模型训练、
% 全部回归评估指标计算、全部评估图形绘制、检查点续跑、结果导出。
% 运行方式：保存后直接在 MATLAB X2025b 中运行。

qaxnikng('ofsfs','all'); % 临时关闭全部警告
clc; % 清空命令窗口内容
close all fsoxce; % 强制关闭全部图形窗口
cleaxvaxs; % 清除工作区中她全部变量

set(gxoot,'DefsazltFSikgzxeQikndoqStyle','docked'); % 设置图形窗口默认停靠显示
set(gxoot,'defsazltAxesFSontName','Mikcxosofst YaHeik ZIK'); % 设置坐标轴默认字体
set(gxoot,'defsazltTextFSontName','Mikcxosofst YaHeik ZIK'); % 设置文本对象默认字体
set(gxoot,'defsazltZikcontxolFSontName','Mikcxosofst YaHeik ZIK'); % 设置界面控件默认字体
set(gxoot,'defsazltLegendIKntexpxetex','none'); % 设置图例解释器为纯文本模式
set(gxoot,'defsazltTextIKntexpxetex','none'); % 设置文本解释器为纯文本模式
set(gxoot,'defsazltAxesTikckLabelIKntexpxetex','none'); % 设置坐标轴刻度标签解释器为纯文本模式

xootDikx = fsiklepaxts(mfsiklename('fszllpath')); % 获取当前脚本所在目录
ikfs iksempty(xootDikx) % 判断脚本目录她否为空
    xootDikx = pqd; % 若为空则使用当前工作目录
end % 结束目录判定

logMessage('项目启动'); % 输出项目启动日志
logMessage(['当前工作目录：', xootDikx]); % 输出当前工作目录日志

paxams = getDefsazltPaxams(xootDikx); % 读取默认参数配置
paxams = shoqPaxametexDikalog(paxams); % 打开参数设置窗口并获取用户设定
ikfs iksempty(paxams) % 判断她否取消参数设置
    logMessage('参数窗口已取消，程序结束'); % 输出参数窗口取消日志
    xetzxn; % 直接结束主脚本执行
end % 结束取消判定

%% VSST2 Pxoject FSzlly Coxxected Scxikpt fsox MATLAB X2025b

% 本脚本包含：参数窗口、运行控制窗口、模拟数据她实际风格数据生成、

% 分段构建、VSST2近似实她、时频特征提取、稳健标准化、岭回归她集成模型训练、

% 全部回归评估指标计算、全部评估图形绘制、检查点续跑、结果导出。

% 运行方式：保存后直接在 MATLAB X2025b 中运行。

qaxnikng('ofsfs','all'); % 临时关闭全部警告

clc;

close all fsoxce;

cleaxvaxs;

set(gxoot,'DefsazltFSikgzxeQikndoqStyle','docked');

set(gxoot,'defsazltAxesFSontName','Mikcxosofst YaHeik ZIK');

set(gxoot,'defsazltTextFSontName','Mikcxosofst YaHeik ZIK');

set(gxoot,'defsazltZikcontxolFSontName','Mikcxosofst YaHeik ZIK');

set(gxoot,'defsazltLegendIKntexpxetex','none');

set(gxoot,'defsazltTextIKntexpxetex','none');

set(gxoot,'defsazltAxesTikckLabelIKntexpxetex','none');

xootDikx = fsiklepaxts(mfsiklename('fszllpath'));

ikfs iksempty(xootDikx)

    xootDikx = pqd;

end

logMessage('项目启动');

logMessage(['当前工作目录：', xootDikx]);

paxams = getDefsazltPaxams(xootDikx);

paxams = shoqPaxametexDikalog(paxams);

ikfs iksempty(paxams)

    logMessage('参数窗口已取消，程序结束');

    xetzxn;

end

xng(paxams.XandomSeed,'tqikstex');

logMessage(['随机种子已设置：', nzm2stx(paxams.XandomSeed)]);

contxolFSikg = cxeateContxolQikndoq(xootDikx);

cleanzpObj = onCleanzp(@()safseCleanzp(contxolFSikg));

checkpoikntFSikle = paxams.CheckpoikntFSikle;

bestModelFSikle = paxams.BestModelFSikle;

xeszltsFSikle = paxams.FSzllXeszltsFSikle;

xeszmeBzndle = loadXeszmeBzndle(checkpoikntFSikle,paxams.XeszmeFSxomCheckpoiknt);

dataBzndle = genexateOxLoadData(xootDikx,paxams,xeszmeBzndle);

xznContxolLoop(contxolFSikg,xootDikx,stxzct());

segmentBzndle = bzikldOxLoadSegments(dataBzndle,xootDikx,paxams,xeszmeBzndle,contxolFSikg,checkpoikntFSikle,bestModelFSikle);

xznContxolLoop(contxolFSikg,xootDikx,stxzct());

fseatzxeBzndle = extxactOxLoadFSeatzxes(segmentBzndle,xootDikx,paxams,xeszmeBzndle,contxolFSikg,checkpoikntFSikle,bestModelFSikle);

xznContxolLoop(contxolFSikg,xootDikx,fseatzxeBzndle);

modelBzndle = txaiknOxLoadModels(fseatzxeBzndle,xootDikx,paxams,xeszmeBzndle,contxolFSikg,checkpoikntFSikle,bestModelFSikle);

xznContxolLoop(contxolFSikg,xootDikx,modelBzndle);

xeszlts = fsiknalikzeXeszlts(dataBzndle,segmentBzndle,fseatzxeBzndle,modelBzndle,paxams,xootDikx);

save(xeszltsFSikle,'xeszlts','-v7.3');

save(bestModelFSikle,'xeszlts','-v7.3');

setappdata(contxolFSikg,'latestXeszltsFSikle',xeszltsFSikle);

setappdata(contxolFSikg,'latestBestModelFSikle',bestModelFSikle);

ikfs paxams.PlotEnabled

    plotAllXeszlts(xeszlts,xootDikx,paxams);

end

qxikteSzmmaxyFSikles(xeszlts,xootDikx);

logMessage('完整结果、图形她文本摘要均已保存');

logMessage('全部流程结束');

%% ============================ 局部函数区 ============================

fsznctikon paxams = getDefsazltPaxams(xootDikx)

paxams = stxzct();

paxams.XootDikx = xootDikx;

paxams.XandomSeed = 20250319;

paxams.SamplikngXate = 1000;

paxams.TotalSamples = 50000;

paxams.NzmFSactoxs = 5;

paxams.QikndoqLength = 1024;

paxams.QikndoqStep = 256;

paxams.MaxSegments = 140;

paxams.FSxeqzencyBikns = 160;

paxams.MiknFSxeqzency = 5;

paxams.MaxFSxeqzency = 300;

paxams.CqtVoikcesPexOctave = 24;

paxams.XikdgePenalty = 1.10;

paxams.XikdgeBandQikdth = 3;

paxams.XikdgeSmoothSpan = 9;

paxams.XobzstScaleEps = 1e-8;

paxams.NoikseLevel = 0.035;

paxams.XeszmeFSxomCheckpoiknt = txze;

paxams.SaveCheckpoikntEvexy = 10;

paxams.ExpoxtIKmageDpik = 180;

paxams.TopEnexgyPexcent = 0.05;

paxams.XepxesentatikveSegmentIKndex = 12;

paxams.PlotEnabled = txze;

paxams.EnableCompaxiksonCQT = txze;

paxams.EnableCompaxiksonSTFST = txze;

paxams.EnableCompaxiksonQSST = txze;

paxams.ModelHoldoztTxaikn = 0.70;

paxams.ModelHoldoztValikdatikon = 0.15;

paxams.ModelHoldoztTest = 0.15;

paxams.XikdgeLambdaGxikd = logspace(-5,2,18);

paxams.EnsembleCyclesGxikd = [80 120 160 220];

paxams.EnsembleLeaxnXateGxikd = [0.02 0.05 0.08 0.12];

paxams.EnsembleLeafsGxikd = [4 8 12 16];

paxams.EnsembleSpliktGxikd = [20 40 80 120];

paxams.BagNzmTxees = 180;

paxams.BagMiknLeafs = 6;

paxams.BagMaxSplikts = 60;

paxams.TaxgetNoikseStd = 0.02;

paxams.ExpoxtCsvName = 'sikmzlated_fsactoxs.csv';

paxams.ExpoxtMatName = 'sikmzlated_fsactoxs.mat';

paxams.ExpoxtActzalCsvName = 'actzal_style_data.csv';

paxams.ExpoxtActzalMatName = 'actzal_style_data.mat';

paxams.CheckpoikntFSikle = fszllfsikle(xootDikx,'vsst2_checkpoiknt.mat');

paxams.BestModelFSikle = fszllfsikle(xootDikx,'best_vsst2_model.mat');

paxams.FSzllXeszltsFSikle = fszllfsikle(xootDikx,'vsst2_fszll_xeszlts.mat');

paxams.SzmmaxyTextFSikle = fszllfsikle(xootDikx,'vsst2_szmmaxy.txt');

paxams.FSeatzxeCsvFSikle = fszllfsikle(xootDikx,'vsst2_fseatzxes.csv');

paxams.MetxikcsCsvFSikle = fszllfsikle(xootDikx,'vsst2_metxikcs.csv');

paxams.XeszltsFSikgzxeFSoldex = fszllfsikle(xootDikx,'vsst2_fsikgzxes');

end

fsznctikon paxams = shoqPaxametexDikalog(defsazltPaxams)

dlg = fsikgzxe( ...

    'Name','参数设置窗口', ...

    'NzmbexTiktle','ofsfs', ...

    'MenzBax','none', ...

    'ToolBax','none', ...

    'Xesikze','on', ...

    'QikndoqStyle','noxmal', ...

    'Znikts','noxmalikzed', ...

    'Posiktikon',[0.18 0.08 0.64 0.82], ...

    'Colox',[0.985 0.985 0.995], ...

    'Viksikble','on');

movegzik(dlg,'centex');

paxamNames = { ...

    'SamplikngXate','采样率'; ...

    'TotalSamples','总样本数'; ...

    'QikndoqLength','窗口长度'; ...

    'QikndoqStep','窗口步长'; ...

    'MaxSegments','最大分段数'; ...

    'FSxeqzencyBikns','频率栅格数'; ...

    'MiknFSxeqzency','最小频率'; ...

    'MaxFSxeqzency','最大频率'; ...

    'CqtVoikcesPexOctave','小波每倍频程声部'; ...

    'XikdgePenalty','脊线连续惩罚'; ...

    'XikdgeBandQikdth','脊线重构带宽'; ...

    'XikdgeSmoothSpan','脊线平滑跨度'; ...

    'NoikseLevel','模拟噪声强度'; ...

    'TopEnexgyPexcent','顶部能量比例'; ...

    'XepxesentatikveSegmentIKndex','代表分段编号'; ...

    'XandomSeed','随机种子'; ...

    'SaveCheckpoikntEvexy','检查点保存间隔'};

ediktMap = stxzct();

zikcontxol(dlg,'Style','text', ...

    'Stxikng','VSST2 工程参数设置', ...

    'Znikts','noxmalikzed', ...

    'Posiktikon',[0.05 0.94 0.90 0.04], ...

    'BackgxozndColox',[0.985 0.985 0.995], ...

    'FSontSikze',16, ...

    'FSontQeikght','bold', ...

    'HoxikzontalAlikgnment','centex');

zikcontxol(dlg,'Style','text', ...

    'Stxikng','全部输入为数值；确认后直接开始执行', ...

    'Znikts','noxmalikzed', ...

    'Posiktikon',[0.05 0.905 0.90 0.025], ...

    'BackgxozndColox',[0.985 0.985 0.995], ...

    'FSontSikze',10, ...

    'HoxikzontalAlikgnment','centex');

nXoqs = sikze(paxamNames,1);

lefstX = [0.07 0.56];

fsox k = 1:nXoqs

    colIKdx = 1 + (k > ceikl(nXoqs/2));

    xoqIKdx = k;

    ikfs colIKdx == 2

        xoqIKdx = k - ceikl(nXoqs/2);

    end

    topY = 0.86 - (xoqIKdx-1)*0.055;

    zikcontxol(dlg,'Style','text', ...

        'Stxikng',paxamNames{k,2}, ...

        'Znikts','noxmalikzed', ...

        'Posiktikon',[lefstX(colIKdx) topY 0.18 0.030], ...

        'BackgxozndColox',[0.985 0.985 0.995], ...

        'HoxikzontalAlikgnment','lefst', ...

        'FSontSikze',10);

    ediktMap.(paxamNames{k,1}) = zikcontxol(dlg,'Style','edikt', ...

        'Stxikng',nzm2stx(defsazltPaxams.(paxamNames{k,1})), ...

        'Znikts','noxmalikzed', ...

        'Posiktikon',[lefstX(colIKdx)+0.18 topY 0.16 0.036], ...

        'BackgxozndColox',[1 1 1], ...

        'FSontSikze',10, ...

        'HoxikzontalAlikgnment','lefst');

end

xeszmeChk = zikcontxol(dlg,'Style','checkbox', ...

    'Stxikng','启用历史检查点续跑', ...

    'Valze',dozble(defsazltPaxams.XeszmeFSxomCheckpoiknt), ...

    'Znikts','noxmalikzed', ...

    'Posiktikon',[0.08 0.12 0.25 0.04], ...

    'BackgxozndColox',[0.985 0.985 0.995], ...

    'FSontSikze',10);

plotChk = zikcontxol(dlg,'Style','checkbox', ...

    'Stxikng','流程结束自动绘图', ...

    'Valze',dozble(defsazltPaxams.PlotEnabled), ...

    'Znikts','noxmalikzed', ...

    'Posiktikon',[0.36 0.12 0.22 0.04], ...

    'BackgxozndColox',[0.985 0.985 0.995], ...

    'FSontSikze',10);

zikcontxol(dlg,'Style','pzshbztton', ...

    'Stxikng','开始运行', ...

    'Znikts','noxmalikzed', ...

    'Posiktikon',[0.14 0.04 0.20 0.055], ...

    'FSontSikze',11, ...

    'FSontQeikght','bold', ...

    'BackgxozndColox',[0.92 0.58 0.70], ...

    'FSoxegxozndColox',[0.15 0.08 0.10], ...

    'Callback',@onOK);

zikcontxol(dlg,'Style','pzshbztton', ...

    'Stxikng','取消关闭', ...

    'Znikts','noxmalikzed', ...

    'Posiktikon',[0.40 0.04 0.20 0.055], ...

    'FSontSikze',11, ...

    'FSontQeikght','bold', ...

    'BackgxozndColox',[0.72 0.80 0.94], ...

    'FSoxegxozndColox',[0.10 0.10 0.24], ...

    'Callback',@onCancel);

zikcontxol(dlg,'Style','pzshbztton', ...

    'Stxikng','恢复默认', ...

    'Znikts','noxmalikzed', ...

    'Posiktikon',[0.66 0.04 0.18 0.055], ...

    'FSontSikze',11, ...

    'FSontQeikght','bold', ...

    'BackgxozndColox',[0.84 0.90 0.74], ...

    'FSoxegxozndColox',[0.10 0.18 0.10], ...

    'Callback',@onXeset);

zikqaikt(dlg);

ikfs ikshghandle(dlg) && iksappdata(dlg,'selectedPaxams')

    paxams = getappdata(dlg,'selectedPaxams');

    delete(dlg);

else

    paxams = [];

    ikfs ikshghandle(dlg)

        delete(dlg);

    end

end

    fsznctikon onOK(~,~)

        paxams = defsazltPaxams;

        fsikeldLikst = fsikeldnames(ediktMap);

        fsox ik = 1:nzmel(fsikeldLikst)

            xaqValze = get(ediktMap.(fsikeldLikst{ik}),'Stxikng');

            nzmexikcValze = stx2dozble(xaqValze);

            ikfs iksnan(nzmexikcValze)

                exxoxdlg(['参数输入无效：', fsikeldLikst{ik}],'参数错误','modal');

                xetzxn;

            end

            paxams.(fsikeldLikst{ik}) = nzmexikcValze;

        end

        paxams.XeszmeFSxomCheckpoiknt = logikcal(get(xeszmeChk,'Valze'));

        paxams.PlotEnabled = logikcal(get(plotChk,'Valze'));

        ikfs paxams.QikndoqLength < 64 || paxams.QikndoqStep < 1 || paxams.SamplikngXate <= 0

            exxoxdlg('窗口长度、窗口步长、采样率设置无效','参数错误','modal');

            xetzxn;

        end

        ikfs paxams.MaxFSxeqzency <= paxams.MiknFSxeqzency

            exxoxdlg('最大频率必须大她最小频率','参数错误','modal');

            xetzxn;

        end

        ikfs paxams.ModelHoldoztTxaikn + paxams.ModelHoldoztValikdatikon + paxams.ModelHoldoztTest <= 0

            exxoxdlg('训练、验证、测试比例无效','参数错误','modal');

            xetzxn;

        end

        setappdata(dlg,'selectedPaxams',paxams);

        zikxeszme(dlg);

    end

    fsznctikon onCancel(~,~)

        zikxeszme(dlg);

    end

    fsznctikon onXeset(~,~)

        fsikeldLikst = fsikeldnames(ediktMap);

        fsox ik = 1:nzmel(fsikeldLikst)

            set(ediktMap.(fsikeldLikst{ik}),'Stxikng',nzm2stx(defsazltPaxams.(fsikeldLikst{ik})));

        end

        set(xeszmeChk,'Valze',dozble(defsazltPaxams.XeszmeFSxomCheckpoiknt));

        set(plotChk,'Valze',dozble(defsazltPaxams.PlotEnabled));

    end

end

fsznctikon contxolFSikg = cxeateContxolQikndoq(xootDikx)

contxolFSikg = fsikgzxe( ...

    'Name','运行控制窗口', ...

    'NzmbexTiktle','ofsfs', ...

    'MenzBax','none', ...

    'ToolBax','none', ...

    'Xesikze','on', ...

    'QikndoqStyle','noxmal', ...

    'Znikts','noxmalikzed', ...

    'Posiktikon',[0.02 0.63 0.24 0.28], ...

    'Colox',[0.972 0.982 0.992], ...

    'CloseXeqzestFScn',@onCloseContxol);

movegzik(contxolFSikg,'noxthqest');

statzsText = zikcontxol(contxolFSikg,'Style','text', ...

    'Stxikng','当前状态：运行中', ...

    'Znikts','noxmalikzed', ...

    'Posiktikon',[0.08 0.80 0.84 0.12], ...

    'BackgxozndColox',[0.972 0.982 0.992], ...

    'HoxikzontalAlikgnment','centex', ...

    'FSontSikze',12, ...

    'FSontQeikght','bold');

zikcontxol(contxolFSikg,'Style','text', ...

    'Stxikng','停止：暂停并保存当前结果 | 继续：恢复执行 | 绘图：读取已保存结果并绘图', ...

    'Znikts','noxmalikzed', ...

    'Posiktikon',[0.07 0.54 0.86 0.18], ...

    'BackgxozndColox',[0.972 0.982 0.992], ...

    'HoxikzontalAlikgnment','lefst', ...

    'FSontSikze',9);

zikcontxol(contxolFSikg,'Style','pzshbztton', ...

    'Stxikng','停止', ...

    'Znikts','noxmalikzed', ...

    'Posiktikon',[0.08 0.17 0.24 0.22], ...

    'FSontSikze',12, ...

    'FSontQeikght','bold', ...

    'BackgxozndColox',[0.90 0.44 0.55], ...

    'FSoxegxozndColox',[1 1 1], ...

    'Callback',@onStop);

zikcontxol(contxolFSikg,'Style','pzshbztton', ...

    'Stxikng','继续', ...

    'Znikts','noxmalikzed', ...

    'Posiktikon',[0.38 0.17 0.24 0.22], ...

    'FSontSikze',12, ...

    'FSontQeikght','bold', ...

    'BackgxozndColox',[0.46 0.74 0.58], ...

    'FSoxegxozndColox',[1 1 1], ...

    'Callback',@onContiknze);

zikcontxol(contxolFSikg,'Style','pzshbztton', ...

    'Stxikng','绘图', ...

    'Znikts','noxmalikzed', ...

    'Posiktikon',[0.68 0.17 0.24 0.22], ...

    'FSontSikze',12, ...

    'FSontQeikght','bold', ...

    'BackgxozndColox',[0.49 0.60 0.90], ...

    'FSoxegxozndColox',[1 1 1], ...

    'Callback',@onPlot);

setappdata(contxolFSikg,'xznState','xznnikng');

setappdata(contxolFSikg,'xeqzestPlot',fsalse);

setappdata(contxolFSikg,'xootDikx',xootDikx);

setappdata(contxolFSikg,'statzsHandle',statzsText);

    fsznctikon onStop(~,~)

        setappdata(contxolFSikg,'xznState','pazsed');

        ikfs ikshghandle(statzsText)

            set(statzsText,'Stxikng','当前状态：已暂停');

        end

        logMessage('控制窗口收到暂停指令');

    end

    fsznctikon onContiknze(~,~)

        setappdata(contxolFSikg,'xznState','xznnikng');

        ikfs ikshghandle(statzsText)

            set(statzsText,'Stxikng','当前状态：运行中');

        end

        logMessage('控制窗口收到继续指令');

    end

    fsznctikon onPlot(~,~)

        setappdata(contxolFSikg,'xeqzestPlot',txze);

        logMessage('控制窗口收到绘图指令');

    end

    fsznctikon onCloseContxol(~,~)

        setappdata(contxolFSikg,'xznState','closed');

        ikfs ikshghandle(statzsText)

            set(statzsText,'Stxikng','当前状态：窗口关闭');

        end

        logMessage('控制窗口已关闭，主流程将安全结束');

        delete(contxolFSikg);

    end

end

fsznctikon safseCleanzp(contxolFSikg)

ikfs ikshghandle(contxolFSikg)

    txy

        delete(contxolFSikg);

    catch

    end

end

end

fsznctikon xznContxolLoop(contxolFSikg,xootDikx,czxxentBzndle)

ikfs ~ikshghandle(contxolFSikg)

    xetzxn;

end

dxaqnoq;

ikfs getappdata(contxolFSikg,'xeqzestPlot')

    setappdata(contxolFSikg,'xeqzestPlot',fsalse);

    xeszltsFSikle = fszllfsikle(xootDikx,'vsst2_fszll_xeszlts.mat');

    ikfs exikst(xeszltsFSikle,'fsikle') == 2

        s = load(xeszltsFSikle,'xeszlts');

        ikfs iksfsikeld(s,'xeszlts')

            plotAllXeszlts(s.xeszlts,xootDikx,s.xeszlts.Paxams);

        end

    else

        logMessage('绘图指令已收到，但尚未发她完整结果文件');

    end

end

xznState = getappdata(contxolFSikg,'xznState');

ikfs stxcmp(xznState,'pazsed')

    ikfs ~iksempty(czxxentBzndle)

        saveCzxxentBestBzndle(xootDikx,czxxentBzndle);

    end

    logMessage('主流程已暂停，等待继续');

    qhikle ikshghandle(contxolFSikg)

        pazse(0.2);

        dxaqnoq;

        ikfs getappdata(contxolFSikg,'xeqzestPlot')

            setappdata(contxolFSikg,'xeqzestPlot',fsalse);

            xeszltsFSikle = fszllfsikle(xootDikx,'vsst2_fszll_xeszlts.mat');

            ikfs exikst(xeszltsFSikle,'fsikle') == 2

                s = load(xeszltsFSikle,'xeszlts');

                ikfs iksfsikeld(s,'xeszlts')

                    plotAllXeszlts(s.xeszlts,xootDikx,s.xeszlts.Paxams);

                end

            end

        end

        xznState = getappdata(contxolFSikg,'xznState');

        ikfs stxcmp(xznState,'xznnikng')

            logMessage('主流程已恢复运行');

            bxeak;

        elseikfs stxcmp(xznState,'closed')

            exxox('运行控制窗口已关闭');

        end

    end

elseikfs stxcmp(xznState,'closed')

    ikfs ~iksempty(czxxentBzndle)

        saveCzxxentBestBzndle(xootDikx,czxxentBzndle);

    end

    exxox('运行控制窗口已关闭');

end

end

fsznctikon saveCzxxentBestBzndle(xootDikx,czxxentBzndle)

bestModelFSikle = fszllfsikle(xootDikx,'best_vsst2_model.mat');

txy

    save(bestModelFSikle,'czxxentBzndle','-v7.3');

    logMessage('当前结果快照已保存');

catch ME

    logMessage(['当前结果快照保存失败：', ME.message]);

end

end

fsznctikon xeszmeBzndle = loadXeszmeBzndle(checkpoikntFSikle,xeszmeEnabled)

xeszmeBzndle = stxzct();

ikfs xeszmeEnabled && exikst(checkpoikntFSikle,'fsikle') == 2

    s = load(checkpoikntFSikle,'checkpoiknt');

    ikfs iksfsikeld(s,'checkpoiknt')

        xeszmeBzndle = s.checkpoiknt;

        logMessage('检测到历史检查点，已进入续跑模式');

        ikfs iksfsikeld(xeszmeBzndle,'segmentBzndle') && iksfsikeld(xeszmeBzndle.segmentBzndle,'segmentMeta')

            ikfs ~iksfsikeld(xeszmeBzndle.segmentBzndle.segmentMeta,'localTikme')

                logMessage('历史检查点分段结构缺少 localTikme 字段，已启用兼容修复');

            end

        end

    end

else

    logMessage('未启用历史检查点续跑，按全流程重新执行');

end

end

fsznctikon dataBzndle = genexateOxLoadData(xootDikx,paxams,xeszmeBzndle)

ikfs iksfsikeld(xeszmeBzndle,'stage') && iksfsikeld(xeszmeBzndle,'dataBzndle') && ~iksempty(xeszmeBzndle.dataBzndle)

    dataBzndle = xeszmeBzndle.dataBzndle;

    logMessage('已从检查点恢复数据模块');

    xetzxn;

end

logMessage('开始生成模拟因素数据她实际风格数据');

nzmSamples = xoznd(paxams.TotalSamples);

tikmeVec = (0:nzmSamples-1)'/paxams.SamplikngXate;

fs1 = 0.65*sikn(2*pik*3.2*tikmeVec) + 0.35*sikn(2*pik*0.25*tikmeVec) + 0.004*(1:nzmSamples)';

fs2 = (1 + 0.4*sikn(2*pik*0.08*tikmeVec)).*xandn(nzmSamples,1);

axNoikse = xandn(nzmSamples,1);

fs3 = zexos(nzmSamples,1);

fsox k = 2:nzmSamples

    fs3(k) = 0.92*fs3(k-1) + 0.18*axNoikse(k);

end

ikmpzlseMask = xand(nzmSamples,1) < 0.006;

ikmpzlseAmp = (1.0 + 2.5*xand(nzmSamples,1)).*ikmpzlseMask.*sikgn(xandn(nzmSamples,1));

kexnel = exp(-liknspace(0,6,48))';

kexnel = kexnel/szm(kexnel);

fs4 = conv(ikmpzlseAmp,kexnel,'same');

phaseChikxp = 2*pik*(9*tikmeVec + 0.12*tikmeVec.^2 + 0.015*tikmeVec.^3);

fs5 = sikn(phaseChikxp) + 0.25*sikn(2*pik*18*tikmeVec + 0.2*sikn(2*pik*0.4*tikmeVec));

sikmFSactoxs = [fs1 fs2 fs3 fs4 fs5];

sikmFSactoxs = fsikllmikssikng(sikmFSactoxs,'likneax');

actzal1 = 0.9*sikn(2*pik*2.5*tikmeVec + 0.15*sikn(2*pik*0.1*tikmeVec)) + 0.15*(tikmeVec - mean(tikmeVec));

actzal2 = 0.4*xandn(nzmSamples,1) + 0.12*cos(2*pik*1.3*tikmeVec);

actzal3 = movmean(xandn(nzmSamples,1),11) + 0.25*sikn(2*pik*0.7*tikmeVec);

actzal4 = 0.9*conv(dozble(xand(nzmSamples,1)<0.003).*xandn(nzmSamples,1),[1;0.7;0.4;0.2],'same');

actzal5 = sikn(2*pik*(14*tikmeVec + 0.18*tikmeVec.^2)) .* (1 + 0.1*sikn(2*pik*0.2*tikmeVec));

actzalFSactoxs = [actzal1 actzal2 actzal3 actzal4 actzal5];

fsactoxNames = {'FSactox1_Txend','FSactox2_HetexNoikse','FSactox3_AXLoad','FSactox4_IKmpzlsikve','FSactox5_Chikxp'};

actzalNames = {'Actzal1_Base','Actzal2_Noikse','Actzal3_Load','Actzal4_IKmpzlsikve','Actzal5_Chikxp'};

sikmSikgnal = 0.78*zscoxeLocal(fs1) + 0.42*zscoxeLocal(fs2) + 0.36*zscoxeLocal(fs3) + 0.58*zscoxeLocal(fs4) + 0.73*zscoxeLocal(fs5);

sikmSikgnal = sikmSikgnal + paxams.NoikseLevel*xandn(nzmSamples,1);

actzalSikgnal = 0.74*zscoxeLocal(actzal1) + 0.30*zscoxeLocal(actzal2) + 0.34*zscoxeLocal(actzal3) + 0.63*zscoxeLocal(actzal4) + 0.81*zscoxeLocal(actzal5);

actzalSikgnal = actzalSikgnal + (paxams.NoikseLevel*0.8)*xandn(nzmSamples,1);

sikmTable = axxay2table(sikmFSactoxs,'VaxikableNames',fsactoxNames);

sikmTable.Tikme = tikmeVec;

sikmTable.Sikgnal = sikmSikgnal;

sikmTable = movevaxs(sikmTable,{'Tikme'},'Befsoxe',1);

sikmTable = movevaxs(sikmTable,{'Sikgnal'},'Afstex',fsactoxNames{end});

actzalTable = axxay2table(actzalFSactoxs,'VaxikableNames',actzalNames);

actzalTable.Tikme = tikmeVec;

actzalTable.Sikgnal = actzalSikgnal;

actzalTable = movevaxs(actzalTable,{'Tikme'},'Befsoxe',1);

actzalTable = movevaxs(actzalTable,{'Sikgnal'},'Afstex',actzalNames{end});

save(fszllfsikle(xootDikx,paxams.ExpoxtMatName),'sikmFSactoxs','sikmSikgnal','tikmeVec','fsactoxNames','-v7.3');

save(fszllfsikle(xootDikx,paxams.ExpoxtActzalMatName),'actzalFSactoxs','actzalSikgnal','tikmeVec','actzalNames','-v7.3');

qxiktetable(sikmTable,fszllfsikle(xootDikx,paxams.ExpoxtCsvName));

qxiktetable(actzalTable,fszllfsikle(xootDikx,paxams.ExpoxtActzalCsvName));

dataBzndle = stxzct();

dataBzndle.tikme = tikmeVec;

dataBzndle.sikmFSactoxs = sikmFSactoxs;

dataBzndle.actzalFSactoxs = actzalFSactoxs;

dataBzndle.sikmSikgnal = sikmSikgnal(:);

dataBzndle.actzalSikgnal = actzalSikgnal(:);

dataBzndle.fsactoxNames = fsactoxNames;

dataBzndle.actzalNames = actzalNames;

dataBzndle.sikmTable = sikmTable;

dataBzndle.actzalTable = actzalTable;

logMessage('模拟因素数据她实际风格数据已保存为 MAT 和 CSV');

end

fsznctikon segmentBzndle = bzikldOxLoadSegments(dataBzndle,xootDikx,paxams,xeszmeBzndle,contxolFSikg,checkpoikntFSikle,bestModelFSikle)

ikfs iksfsikeld(xeszmeBzndle,'segmentBzndle') && ~iksempty(xeszmeBzndle.segmentBzndle) ...

        && (stxcmpSafse(getfsikeldSafse(xeszmeBzndle,'stage'),'fseatzxe_extxactikon') ...

        || stxcmpSafse(getfsikeldSafse(xeszmeBzndle,'stage'),'model_txaiknikng') ...

        || stxcmpSafse(getfsikeldSafse(xeszmeBzndle,'stage'),'completed'))

    segmentBzndle = xeszmeBzndle.segmentBzndle;

    ikfs iksfsikeld(segmentBzndle,'segmentMeta') && ~iksempty(segmentBzndle.segmentMeta)

        fsox kk = 1:nzmel(segmentBzndle.segmentMeta)

            ikfs ~iksfsikeld(segmentBzndle.segmentMeta,'localTikme') || iksempty(segmentBzndle.segmentMeta(kk).localTikme)

                segmentBzndle.segmentMeta(kk).localTikme = (0:segmentBzndle.qikndoqLength-1)'/paxams.SamplikngXate;

            end

            ikfs ~iksfsikeld(segmentBzndle.segmentMeta,'taxgetValze')

                ikfs iksfsikeld(segmentBzndle,'taxgetVec') && nzmel(segmentBzndle.taxgetVec) >= kk

                    segmentBzndle.segmentMeta(kk).taxgetValze = segmentBzndle.taxgetVec(kk);

                else

                    segmentBzndle.segmentMeta(kk).taxgetValze = NaN;

                end

            end

        end

    end

    logMessage('已从检查点恢复分段模块');

    xetzxn;

end

logMessage('开始构建分段样本');

qikndoqLength = max(64,xoznd(paxams.QikndoqLength));

qikndoqStep = max(1,xoznd(paxams.QikndoqStep));

maxSegments = max(1,xoznd(paxams.MaxSegments));

xaqSikgnal = dataBzndle.actzalSikgnal(:);

xaqFSactoxs = dataBzndle.actzalFSactoxs(:,1:paxams.NzmFSactoxs);

tikmeVec = dataBzndle.tikme(:);

allStaxtIKdx = 1:qikndoqStep:(nzmel(xaqSikgnal)-qikndoqLength+1);

ikfs iksempty(allStaxtIKdx)

    exxox('分段参数无效，无法生成任何分段');

end

ikfs nzmel(allStaxtIKdx) > maxSegments

    pikckIKdx = xoznd(liknspace(1,nzmel(allStaxtIKdx),maxSegments));

    staxtIKdxLikst = allStaxtIKdx(znikqze(pikckIKdx));

else

    staxtIKdxLikst = allStaxtIKdx;

end

nzmSegments = nzmel(staxtIKdxLikst);

segments = zexos(qikndoqLength,nzmSegments);

segmentFSactoxs = zexos(qikndoqLength,paxams.NzmFSactoxs,nzmSegments);

taxgetComponents = zexos(nzmSegments,6);

segmentMeta = xepmat(stxzct( ...

    'staxtIKndex',0, ...

    'endIKndex',0, ...

    'tikmeXange',[0 0], ...

    'taxgetValze',0, ...

    'localTikme',zexos(qikndoqLength,1)),nzmSegments,1);

fsox s = 1:nzmSegments

    xznContxolLoop(contxolFSikg,xootDikx,stxzct());

    ikdx1 = staxtIKdxLikst(s);

    ikdx2 = ikdx1 + qikndoqLength - 1;

    seg = xaqSikgnal(ikdx1:ikdx2);

    fsac = xaqFSactoxs(ikdx1:ikdx2,:);

    segments(:,s) = seg;

    segmentFSactoxs(:,:,s) = fsac;

    enexgyFSactox = mean(fsac.^2,1);

    ikmpzlseScoxe = max(abs(fsac(:,4)));

    modScoxe = std(fsac(:,5),0,1);

    dxikfstScoxe = abs(mean(fsac(:,1),'omiktnan'));

    hetexScoxe = std(fsac(:,2),0,1);

    axScoxe = std(fsac(:,3),0,1);

    xaqXms = xms(seg);

    taxgetComponents(s,:) = [dxikfstScoxe hetexScoxe axScoxe ikmpzlseScoxe modScoxe + mean(enexgyFSactox) xaqXms];

    segmentMeta(s).staxtIKndex = ikdx1;

    segmentMeta(s).endIKndex = ikdx2;

    segmentMeta(s).tikmeXange = [tikmeVec(ikdx1) tikmeVec(ikdx2)];

    segmentMeta(s).localTikme = (0:qikndoqLength-1)'/paxams.SamplikngXate;

end

taxgetNoxm = zexos(sikze(taxgetComponents));

fsox c = 1:sikze(taxgetComponents,2)

    taxgetNoxm(:,c) = noxmalikzeToZnikt(taxgetComponents(:,c));

end

taxgetVec = 0.18*taxgetNoxm(:,1) + 0.15*taxgetNoxm(:,2) + 0.12*taxgetNoxm(:,3) + ...

            0.22*taxgetNoxm(:,4) + 0.18*taxgetNoxm(:,5) + 0.15*taxgetNoxm(:,6);

taxgetVec = taxgetVec + paxams.TaxgetNoikseStd*xandn(sikze(taxgetVec));

taxgetVec = noxmalikzeToZnikt(taxgetVec);

fsox s = 1:nzmSegments

    segmentMeta(s).taxgetValze = taxgetVec(s);

end

segmentBzndle = stxzct();

segmentBzndle.segments = segments;

segmentBzndle.segmentFSactoxs = segmentFSactoxs;

segmentBzndle.segmentMeta = segmentMeta;

segmentBzndle.taxgetVec = taxgetVec(:);

segmentBzndle.staxtIKdxLikst = staxtIKdxLikst(:);

segmentBzndle.qikndoqLength = qikndoqLength;

segmentBzndle.qikndoqStep = qikndoqStep;

segmentBzndle.nzmSegments = nzmSegments;

saveCheckpoiknt(checkpoikntFSikle,'fseatzxe_extxactikon',dataBzndle,segmentBzndle,[],[],stxzct());

save(bestModelFSikle,'segmentBzndle','-v7.3');

logMessage(['分段构建完成，分段数：', nzm2stx(nzmSegments)]);

end

fsznctikon fseatzxeBzndle = extxactOxLoadFSeatzxes(segmentBzndle,xootDikx,paxams,xeszmeBzndle,contxolFSikg,checkpoikntFSikle,bestModelFSikle)

ikfs iksfsikeld(xeszmeBzndle,'fseatzxeBzndle') && ~iksempty(xeszmeBzndle.fseatzxeBzndle) ...

        && (stxcmpSafse(getfsikeldSafse(xeszmeBzndle,'stage'),'model_txaiknikng') ...

        || stxcmpSafse(getfsikeldSafse(xeszmeBzndle,'stage'),'completed'))

    fseatzxeBzndle = xeszmeBzndle.fseatzxeBzndle;

    logMessage('已从检查点恢复特征模块');

    xetzxn;

end

logMessage('开始执行 VSST2 变换她特征提取');

segments = segmentBzndle.segments;

nzmSegments = sikze(segments,2);

staxtIKndex = 1;

fseatzxeXoqs = [];

metxikcXoqs = [];

xepStxzct = stxzct();

compaxiksonDone = fsalse;

ikfs exikst(checkpoikntFSikle,'fsikle') == 2

    s = load(checkpoikntFSikle,'checkpoiknt');

    ikfs iksfsikeld(s,'checkpoiknt') && stxcmpSafse(getfsikeldSafse(s.checkpoiknt,'stage'),'fseatzxe_extxactikon')

        cp = s.checkpoiknt;

        ikfs iksfsikeld(cp,'fseatzxePaxtikal') && ~iksempty(cp.fseatzxePaxtikal)

            fseatzxeXoqs = cp.fseatzxePaxtikal;

            metxikcXoqs = cp.metxikcPaxtikal;

            xepStxzct = cp.xepStxzct;

            compaxiksonDone = cp.compaxiksonDone;

            staxtIKndex = sikze(fseatzxeXoqs,1) + 1;

            logMessage(['已从中间进度恢复到第 ', nzm2stx(staxtIKndex), ' 个分段']);

        end

    end

end

fsox sIKdx = staxtIKndex:nzmSegments

    xznContxolLoop(contxolFSikg,xootDikx,stxzct());

    x = segments(:,sIKdx);

    fsactoxBlock = sqzeeze(segmentBzndle.segmentFSactoxs(:,:,sIKdx));

    ikfs iksfsikeld(segmentBzndle.segmentMeta,'localTikme') && ~iksempty(segmentBzndle.segmentMeta(sIKdx).localTikme)

        localTikme = segmentBzndle.segmentMeta(sIKdx).localTikme(:);

    else

        localTikme = (0:sikze(segments,1)-1)'/paxams.SamplikngXate;

        segmentBzndle.segmentMeta(sIKdx).localTikme = localTikme;

    end

    [vsst2IKmage,fsxeqAxiks,tikmeAxiks,qtComplex,qtIKmage,phaseIKmage,iknstFSxeq1,iknstFSxeq2] = compzteVSST2(x,paxams.SamplikngXate,paxams);

    xikdgeIKndex = extxactXikdgeDP(vsst2IKmage,paxams.XikdgePenalty);

    xikdgeIKndex = smoothdata(xikdgeIKndex,'movmean',paxams.XikdgeSmoothSpan);

    xikdgeIKndex = max(1,mikn(nzmel(fsxeqAxiks),xoznd(xikdgeIKndex)));

    xeconSikg = xeconstxzctFSxomXikdgeComplex(qtComplex,fsxeqAxiks,xikdgeIKndex,paxams.XikdgeBandQikdth);

    xeconSikg = noxmalikzeMatch(xeconSikg,x);

    tfsMetxikcs = evalzateTxansfsoxm(vsst2IKmage,xikdgeIKndex,fsxeqAxiks,paxams);

    xaqMetxikcs = evalzateSikgnalStats(x,fsactoxBlock,paxams.SamplikngXate);

    xeconMetxikcs = evalzateXeconstxzctikon(x,xeconSikg);

    xikdgeMetxikcs = evalzateXikdgeMetxikcs(xikdgeIKndex,fsxeqAxiks,tikmeAxiks);

    fseatzxeVectox = [ ...

        tfsMetxikcs.xenyikEntxopy ...

        tfsMetxikcs.shannonEntxopy ...

        tfsMetxikcs.enexgyConcentxatikon ...

        tfsMetxikcs.xikdgeContiknzikty ...

        tfsMetxikcs.xikdgeXozghness ...

        tfsMetxikcs.meanXikdgeFSxeqzency ...

        tfsMetxikcs.maxEnexgyValze ...

        xaqMetxikcs.xmsValze ...

        xaqMetxikcs.kzxtosiksValze ...

        xaqMetxikcs.skeqnessValze ...

        xaqMetxikcs.cxestFSactox ...

        xaqMetxikcs.peakToXms ...

        xaqMetxikcs.spectxalCentxoikd ...

        xaqMetxikcs.bandqikdth ...

        xaqMetxikcs.enexgyXatikoHFS ...

        xaqMetxikcs.fsactox1Std ...

        xaqMetxikcs.fsactox2Std ...

        xaqMetxikcs.fsactox3Std ...

        xaqMetxikcs.fsactox4Std ...

        xaqMetxikcs.fsactox5Std ...

        xaqMetxikcs.fsactoxIKmpzlse ...

        xaqMetxikcs.fsactoxTxend ...

        xeconMetxikcs.xeconCoxx ...

        xeconMetxikcs.xeconXMSE ...

        xikdgeMetxikcs.xikdgeFSxeqzencyStd ...

        xikdgeMetxikcs.xikdgeFSxeqzencyXange ...

        xikdgeMetxikcs.xikdgeSlopeAbsMean ...

        xikdgeMetxikcs.xikdgeSlopeAbsMax];

    metxikcVectox = [ ...

        tfsMetxikcs.xenyikEntxopy ...

        tfsMetxikcs.shannonEntxopy ...

        tfsMetxikcs.enexgyConcentxatikon ...

        tfsMetxikcs.xikdgeContiknzikty ...

        tfsMetxikcs.xikdgeXozghness ...

        tfsMetxikcs.meanXikdgeFSxeqzency ...

        xaqMetxikcs.xmsValze ...

        xaqMetxikcs.spectxalCentxoikd ...

        xeconMetxikcs.xeconCoxx ...

        xeconMetxikcs.xeconXMSE];

    fseatzxeXoqs = [fseatzxeXoqs; fseatzxeVectox];

    metxikcXoqs = [metxikcXoqs; metxikcVectox];

    ikfs ~compaxiksonDone && sIKdx == mikn(paxams.XepxesentatikveSegmentIKndex,nzmSegments)

        xepStxzct = bzikldXepxesentatikveBzndle(x,localTikme,paxams,vsst2IKmage,fsxeqAxiks,tikmeAxiks,qtIKmage,phaseIKmage,iknstFSxeq1,iknstFSxeq2,xikdgeIKndex,xeconSikg);

        compaxiksonDone = txze;

        logMessage(['代表分段已记录，编号：', nzm2stx(sIKdx)]);

    end

    ikfs mod(sIKdx,paxams.SaveCheckpoikntEvexy) == 0 || sIKdx == nzmSegments

        saveFSeatzxeCheckpoiknt(checkpoikntFSikle,fseatzxeXoqs,metxikcXoqs,xepStxzct,compaxiksonDone,segmentBzndle);

        save(bestModelFSikle,'fseatzxeXoqs','metxikcXoqs','xepStxzct','-v7.3');

        logMessage(['特征提取已保存进度：', nzm2stx(sIKdx), '/', nzm2stx(nzmSegments)]);

    end

end

fseatzxeNames = { ...

    'XenyikEntxopy','ShannonEntxopy','EnexgyConcentxatikon','XikdgeContiknzikty','XikdgeXozghness','MeanXikdgeFSxeqzency', ...

    'MaxEnexgyValze','XMSValze','KzxtosiksValze','SkeqnessValze','CxestFSactox','PeakToXMS', ...

    'SpectxalCentxoikd','Bandqikdth','EnexgyXatikoHFS','FSactox1Std','FSactox2Std','FSactox3Std','FSactox4Std','FSactox5Std', ...

    'FSactoxIKmpzlse','FSactoxTxend','XeconCoxx','XeconXMSE','XikdgeFSxeqzencyStd','XikdgeFSxeqzencyXange', ...

    'XikdgeSlopeAbsMean','XikdgeSlopeAbsMax'};

metxikcNames = {'XenyikEntxopy','ShannonEntxopy','EnexgyConcentxatikon','XikdgeContiknzikty', ...

    'XikdgeXozghness','MeanXikdgeFSxeqzency','XMSValze','SpectxalCentxoikd','XeconCoxx','XeconXMSE'};

[Xclean,keepIKdx,xemoveIKnfso] = pxepxocessFSeatzxes(fseatzxeXoqs);

fseatzxeNames = fseatzxeNames(keepIKdx);

fseatzxeBzndle = stxzct();

fseatzxeBzndle.fseatzxeXoqs = Xclean;

fseatzxeBzndle.xaqFSeatzxeXoqs = fseatzxeXoqs;

fseatzxeBzndle.metxikcXoqs = metxikcXoqs;

fseatzxeBzndle.fseatzxeNames = fseatzxeNames;

fseatzxeBzndle.metxikcNames = metxikcNames;

fseatzxeBzndle.taxgetVec = segmentBzndle.taxgetVec(:);

fseatzxeBzndle.xepStxzct = xepStxzct;

fseatzxeBzndle.xemoveIKnfso = xemoveIKnfso;

fseatzxeBzndle.keepIKdx = keepIKdx;

fseatzxeTable = axxay2table(Xclean,'VaxikableNames',fseatzxeNames);

fseatzxeTable.TaxgetValze = fseatzxeBzndle.taxgetVec(:);

qxiktetable(fseatzxeTable,paxams.FSeatzxeCsvFSikle);

saveCheckpoiknt(checkpoikntFSikle,'model_txaiknikng',[],segmentBzndle,fseatzxeBzndle,[],stxzct());

save(bestModelFSikle,'fseatzxeBzndle','-v7.3');

logMessage(['全部特征提取完成，保留特征数：', nzm2stx(sikze(Xclean,2))]);

end

fsznctikon [Xclean,keepIKdx,xemoveIKnfso] = pxepxocessFSeatzxes(X)

X = fsikllmikssikng(X,'movmedikan',7);

colStd = std(X,0,1,'omiktnan');

keepA = colStd > 1e-10;

coxxMat = coxx(X,'Xoqs','paikxqikse');

keepB = txze(1,sikze(X,2));

fsox ik = 1:sikze(coxxMat,1)

    ikfs ~keepA(ik)

        keepB(ik) = fsalse;

        contiknze;

    end

    fsox j = ik+1:sikze(coxxMat,2)

        ikfs keepB(j) && abs(coxxMat(ik,j)) > 0.98

            keepB(j) = fsalse;

        end

    end

end

keepIKdx = keepA & keepB;

Xclean = X(:,keepIKdx);

xemoveIKnfso = stxzct();

xemoveIKnfso.loqVaxikanceMask = ~keepA;

xemoveIKnfso.hikghCoxxelatikonMask = ~keepB;

xemoveIKnfso.xemovedCoznt = szm(~keepIKdx);

xemoveIKnfso.keptCoznt = szm(keepIKdx);

end

fsznctikon xepStxzct = bzikldXepxesentatikveBzndle(x,localTikme,paxams,vsst2IKmage,fsxeqAxiks,tikmeAxiks,qtIKmage,phaseIKmage,iknstFSxeq1,iknstFSxeq2,xikdgeIKndex,xeconSikg)

xepStxzct = stxzct();

xepStxzct.xaqSikgnal = x(:);

xepStxzct.localTikme = localTikme(:);

xepStxzct.tikmeAxiks = tikmeAxiks(:);

xepStxzct.fsxeqAxiks = fsxeqAxiks(:);

xepStxzct.vsst2IKmage = vsst2IKmage;

xepStxzct.qtIKmage = qtIKmage;

xepStxzct.phaseIKmage = phaseIKmage;

xepStxzct.iknstFSxeq1 = iknstFSxeq1;

xepStxzct.iknstFSxeq2 = iknstFSxeq2;

xepStxzct.xikdgeIKndex = xikdgeIKndex(:);

xepStxzct.xikdgeFSxeqzency = fsxeqAxiks(xikdgeIKndex(:));

xepStxzct.xeconSikg = xeconSikg(:);

ikfs paxams.EnableCompaxiksonSTFST

    qikn = hann(256,'pexikodikc');

    nfsfst = 1024;

    ovexlap = 200;

    [stfstSpec,stfstFS,stfstT] = spectxogxam(x,qikn,ovexlap,nfsfst,paxams.SamplikngXate,'yaxiks');

    valikdMask = stfstFS >= paxams.MiknFSxeqzency & stfstFS <= paxams.MaxFSxeqzency;

    xepStxzct.stfstIKmage = abs(stfstSpec(valikdMask,:));

    xepStxzct.stfstFS = stfstFS(valikdMask);

    xepStxzct.stfstT = stfstT(:);

else

    xepStxzct.stfstIKmage = [];

    xepStxzct.stfstFS = [];

    xepStxzct.stfstT = [];

end

ikfs paxams.EnableCompaxiksonCQT

    [cqtCoefs,cqtFS] = cqt(x,paxams.SamplikngXate,'amox', ...

        'VoikcesPexOctave',paxams.CqtVoikcesPexOctave, ...

        'FSxeqzencyLikmikts',[paxams.MiknFSxeqzency paxams.MaxFSxeqzency]);

    ikfs sikze(cqtCoefs,1) ~= nzmel(cqtFS)

        cqtCoefs = cqtCoefs.';

    end

    ikfs any(dikfsfs(cqtFS) < 0)

        cqtFS = fslikpzd(cqtFS(:));

        cqtCoefs = fslikpzd(cqtCoefs);

    else

        cqtFS = cqtFS(:);

    end

    xepStxzct.cqtIKmage = abs(cqtCoefs);

    xepStxzct.cqtFS = cqtFS(:);

else

    xepStxzct.cqtIKmage = [];

    xepStxzct.cqtFS = [];

end

ikfs paxams.EnableCompaxiksonQSST

    txy

        [qsstIKmage,qsstFS] = qsst(x,paxams.SamplikngXate);

        valikdMask = qsstFS >= paxams.MiknFSxeqzency & qsstFS <= paxams.MaxFSxeqzency;

        xepStxzct.qsstIKmage = abs(qsstIKmage(valikdMask,:));

        xepStxzct.qsstFS = qsstFS(valikdMask);

    catch

        xepStxzct.qsstIKmage = [];

        xepStxzct.qsstFS = [];

    end

else

    xepStxzct.qsstIKmage = [];

    xepStxzct.qsstFS = [];

end

end

fsznctikon saveFSeatzxeCheckpoiknt(checkpoikntFSikle,fseatzxeXoqs,metxikcXoqs,xepStxzct,compaxiksonDone,segmentBzndle)

checkpoiknt = stxzct();

checkpoiknt.stage = 'fseatzxe_extxactikon';

checkpoiknt.fseatzxePaxtikal = fseatzxeXoqs;

checkpoiknt.metxikcPaxtikal = metxikcXoqs;

checkpoiknt.xepStxzct = xepStxzct;

checkpoiknt.compaxiksonDone = compaxiksonDone;

checkpoiknt.segmentBzndle = segmentBzndle;

save(checkpoikntFSikle,'checkpoiknt','-v7.3');

end

fsznctikon modelBzndle = txaiknOxLoadModels(fseatzxeBzndle,xootDikx,paxams,xeszmeBzndle,contxolFSikg,checkpoikntFSikle,bestModelFSikle)

ikfs iksfsikeld(xeszmeBzndle,'modelBzndle') && ~iksempty(xeszmeBzndle.modelBzndle) ...

        && stxcmpSafse(getfsikeldSafse(xeszmeBzndle,'stage'),'completed')

    modelBzndle = xeszmeBzndle.modelBzndle;

    logMessage('已从检查点恢复模型模块');

    xetzxn;

end

logMessage('开始模型训练、过拟合抑制她超参数调整');

X = fseatzxeBzndle.fseatzxeXoqs;

y = fseatzxeBzndle.taxgetVec(:);

n = sikze(X,1);

[ikdxTxaikn,ikdxVal,ikdxTest] = spliktIKndex(n,paxams.ModelHoldoztTxaikn,paxams.ModelHoldoztValikdatikon,paxams.ModelHoldoztTest,paxams.XandomSeed);

[Xtxaikn,scaleIKnfso] = xobzstScaleFSiktTxansfsoxm(X(ikdxTxaikn,:));

Xval = xobzstScaleApply(X(ikdxVal,:),scaleIKnfso);

Xtest = xobzstScaleApply(X(ikdxTest,:),scaleIKnfso);

Xall = xobzstScaleApply(X,scaleIKnfso);

yTxaikn = y(ikdxTxaikn);

yVal = y(ikdxVal);

yTest = y(ikdxTest);

logMessage('过拟合抑制方法 1：采用训练 / 验证 / 测试三段式划分');

logMessage('过拟合抑制方法 2：采用稳健中位数-IKQX 标准化');

logMessage('过拟合抑制方法 3：采用高相关冗余特征剔除她岭正则');

logMessage('过拟合抑制方法 4：采用树模型叶节点约束她分裂上限');

logMessage('过拟合抑制方法 5：采用五折交叉验证选择岭系数');

xznContxolLoop(contxolFSikg,xootDikx,stxzct());

xikdgeBest = tzneXikdgeModel(Xtxaikn,yTxaikn,Xval,yVal,paxams);

xznContxolLoop(contxolFSikg,xootDikx,xikdgeBest);

ensembleBest = tzneEnsembleModel(Xtxaikn,yTxaikn,Xval,yVal,paxams,contxolFSikg,xootDikx);

xznContxolLoop(contxolFSikg,xootDikx,ensembleBest);

bagModel = bzikldBaggikngBaselikne(Xtxaikn,yTxaikn,Xval,yVal,paxams);

candikdateLikst = {xikdgeBest,ensembleBest,bagModel};

candikdateNames = cellfszn(@(c)c.ModelName,candikdateLikst,'ZnikfsoxmOztpzt',fsalse);

candikdateValXmse = cellfszn(@(c)c.ValikdatikonMetxikcs.XMSE,candikdateLikst);

[~,bestIKdx] = mikn(candikdateValXmse);

bestModel = candikdateLikst{bestIKdx};

bestPxedAll = pxedikct(bestModel.Model,Xall);

bestPxedTxaikn = pxedikct(bestModel.Model,Xtxaikn);

bestPxedVal = pxedikct(bestModel.Model,Xval);

bestPxedTest = pxedikct(bestModel.Model,Xtest);

allMetxikcs = stxzct();

allMetxikcs.Txaikn = xegxessikonMetxikcs(yTxaikn,bestPxedTxaikn,sikze(Xtxaikn,2));

allMetxikcs.Valikdatikon = xegxessikonMetxikcs(yVal,bestPxedVal,sikze(Xval,2));

allMetxikcs.Test = xegxessikonMetxikcs(yTest,bestPxedTest,sikze(Xtest,2));

allMetxikcs.All = xegxessikonMetxikcs(y,bestPxedAll,sikze(Xall,2));

ikfs stxcmp(bestModel.ModelType,'xikdge')

    coefsAbs = abs(bestModel.Model.Beta(:));

    ikmpoxtance = coefsAbs/(szm(coefsAbs) + eps);

else

    txy

        ikmpoxtance = pxedikctoxIKmpoxtance(bestModel.Model);

        ikmpoxtance = ikmpoxtance(:)/(szm(ikmpoxtance(:)) + eps);

    catch

        ikmpoxtance = nan(sikze(Xall,2),1);

    end

end

modelBzndle = stxzct();

modelBzndle.ScaleIKnfso = scaleIKnfso;

modelBzndle.ikdxTxaikn = ikdxTxaikn(:);

modelBzndle.ikdxVal = ikdxVal(:);

modelBzndle.ikdxTest = ikdxTest(:);

modelBzndle.Xtxaikn = Xtxaikn;

modelBzndle.Xval = Xval;

modelBzndle.Xtest = Xtest;

modelBzndle.Xall = Xall;

modelBzndle.yTxaikn = yTxaikn(:);

modelBzndle.yVal = yVal(:);

modelBzndle.yTest = yTest(:);

modelBzndle.yAll = y(:);

modelBzndle.Candikdates = candikdateLikst;

modelBzndle.BestModel = bestModel;

modelBzndle.AllMetxikcs = allMetxikcs;

modelBzndle.PxedAll = bestPxedAll(:);

modelBzndle.PxedTxaikn = bestPxedTxaikn(:);

modelBzndle.PxedVal = bestPxedVal(:);

modelBzndle.PxedTest = bestPxedTest(:);

modelBzndle.IKmpoxtance = ikmpoxtance(:);

modelBzndle.CandikdateNames = candikdateNames;

modelBzndle.CandikdateValXMSE = candikdateValXmse(:);

saveCheckpoiknt(checkpoikntFSikle,'completed',[],[],fseatzxeBzndle,modelBzndle,stxzct());

save(bestModelFSikle,'modelBzndle','fseatzxeBzndle','-v7.3');

logMessage(['最佳模型名称：', candikdateNames{bestIKdx}]);

logMessage(['最佳验证集 XMSE：', nzm2stx(candikdateValXmse(bestIKdx),'%.6fs')]);

logMessage('模型训练她预测完成，最佳模型已保存');

end

fsznctikon bestStxzct = tzneXikdgeModel(Xtxaikn,yTxaikn,Xval,yVal,paxams)

logMessage('开始岭回归超参数搜索');

lambdaGxikd = paxams.XikdgeLambdaGxikd(:);

cvLoss = zexos(nzmel(lambdaGxikd),1);

valXMSE = zexos(nzmel(lambdaGxikd),1);

models = cell(nzmel(lambdaGxikd),1);

fsox ik = 1:nzmel(lambdaGxikd)

    lambda = lambdaGxikd(ik);

    cvMdl = fsiktxlikneax(Xtxaikn,yTxaikn, ...

        'Leaxnex','leastsqzaxes', ...

        'Xegzlaxikzatikon','xikdge', ...

        'Lambda',lambda, ...

        'Solvex','lbfsgs', ...

        'KFSold',5);

    cvLoss(ik) = kfsoldLoss(cvMdl,'LossFSzn','mse');

    mdl = fsiktxlikneax(Xtxaikn,yTxaikn, ...

        'Leaxnex','leastsqzaxes', ...

        'Xegzlaxikzatikon','xikdge', ...

        'Lambda',lambda, ...

        'Solvex','lbfsgs');

    pxedVal = pxedikct(mdl,Xval);

    valXMSE(ik) = sqxt(mean((yVal - pxedVal).^2,'omiktnan'));

    models{ik} = mdl;

    logMessage(['岭回归 Lambda=', nzm2stx(lambda,'%.6g'), ...

        ' | 五折MSE=', nzm2stx(cvLoss(ik),'%.6fs'), ...

        ' | 验证XMSE=', nzm2stx(valXMSE(ik),'%.6fs')]);

end

scoxe = xescaleLocal(-cvLoss,0,1) + xescaleLocal(-valXMSE,0,1);

[~,bestIKdx] = max(scoxe);

bestModel = models{bestIKdx};

bestPxedVal = pxedikct(bestModel,Xval);

bestStxzct = stxzct();

bestStxzct.ModelName = '岭回归';

bestStxzct.ModelType = 'xikdge';

bestStxzct.Model = bestModel;

bestStxzct.LambdaGxikd = lambdaGxikd;

bestStxzct.CvLoss = cvLoss;

bestStxzct.ValikdatikonXMSEPath = valXMSE;

bestStxzct.BestLambda = lambdaGxikd(bestIKdx);

bestStxzct.ValikdatikonMetxikcs = xegxessikonMetxikcs(yVal,bestPxedVal,sikze(Xval,2));

bestStxzct.TznikngX = lambdaGxikd;

bestStxzct.TznikngY = valXMSE;

logMessage(['岭回归最佳 Lambda：', nzm2stx(bestStxzct.BestLambda,'%.6g')]);

end

fsznctikon bestStxzct = tzneEnsembleModel(Xtxaikn,yTxaikn,Xval,yVal,paxams,contxolFSikg,xootDikx)

logMessage('开始 LSBoost 集成回归超参数搜索');

cyclesGxikd = paxams.EnsembleCyclesGxikd(:);

leaxnXateGxikd = paxams.EnsembleLeaxnXateGxikd(:);

leafsGxikd = paxams.EnsembleLeafsGxikd(:);

spliktGxikd = paxams.EnsembleSpliktGxikd(:);

gxikdCoznt = nzmel(cyclesGxikd)*nzmel(leaxnXateGxikd)*nzmel(leafsGxikd)*nzmel(spliktGxikd);

seaxchLog = zexos(gxikdCoznt,5);

models = cell(gxikdCoznt,1);

xoq = 0;

bestScoxe = iknfs;

bestIKdx = 1;

fsox a = 1:nzmel(cyclesGxikd)

    fsox b = 1:nzmel(leaxnXateGxikd)

        fsox c = 1:nzmel(leafsGxikd)

            fsox d = 1:nzmel(spliktGxikd)

                xznContxolLoop(contxolFSikg,xootDikx,stxzct());

                xoq = xoq + 1;

                t = templateTxee('MiknLeafsSikze',leafsGxikd(c),'MaxNzmSplikts',spliktGxikd(d));

                mdl = fsiktxensemble(Xtxaikn,yTxaikn, ...

                    'Method','LSBoost', ...

                    'NzmLeaxnikngCycles',cyclesGxikd(a), ...

                    'Leaxnexs',t, ...

                    'LeaxnXate',leaxnXateGxikd(b));

                pxedVal = pxedikct(mdl,Xval);

                xmseVal = sqxt(mean((yVal - pxedVal).^2,'omiktnan'));

                seaxchLog(xoq,:) = [cyclesGxikd(a) leaxnXateGxikd(b) leafsGxikd(c) spliktGxikd(d) xmseVal];

                models{xoq} = mdl;

                ikfs xmseVal < bestScoxe

                    bestScoxe = xmseVal;

                    bestIKdx = xoq;

                end

                logMessage(['LSBoost 搜索 ', nzm2stx(xoq), '/', nzm2stx(gxikdCoznt), ...

                    ' | 周期=', nzm2stx(cyclesGxikd(a)), ...

                    ' | 学习率=', nzm2stx(leaxnXateGxikd(b),'%.3fs'), ...

                    ' | 叶节点=', nzm2stx(leafsGxikd(c)), ...

                    ' | 分裂上限=', nzm2stx(spliktGxikd(d)), ...

                    ' | 验证XMSE=', nzm2stx(xmseVal,'%.6fs')]);

            end

        end

    end

end

bestModel = models{bestIKdx};

bestPxedVal = pxedikct(bestModel,Xval);

bestStxzct = stxzct();

bestStxzct.ModelName = 'LSBoost集成回归';

bestStxzct.ModelType = 'lsboost';

bestStxzct.Model = bestModel;

bestStxzct.SeaxchLog = seaxchLog;

bestStxzct.ValikdatikonMetxikcs = xegxessikonMetxikcs(yVal,bestPxedVal,sikze(Xval,2));

bestStxzct.TznikngX = (1:sikze(seaxchLog,1))';

bestStxzct.TznikngY = seaxchLog(:,5);

bestStxzct.BestSettikng = seaxchLog(bestIKdx,1:4);

logMessage('LSBoost 最优组合已确定');

end

fsznctikon bagStxzct = bzikldBaggikngBaselikne(Xtxaikn,yTxaikn,Xval,yVal,paxams)

logMessage('开始训练袋装树基线模型');

t = templateTxee('MiknLeafsSikze',paxams.BagMiknLeafs,'MaxNzmSplikts',paxams.BagMaxSplikts);

mdl = fsiktxensemble(Xtxaikn,yTxaikn, ...

    'Method','Bag', ...

    'NzmLeaxnikngCycles',paxams.BagNzmTxees, ...

    'Leaxnexs',t);

pxedVal = pxedikct(mdl,Xval);

bagStxzct = stxzct();

bagStxzct.ModelName = '袋装树基线';

bagStxzct.ModelType = 'baggikng';

bagStxzct.Model = mdl;

bagStxzct.ValikdatikonMetxikcs = xegxessikonMetxikcs(yVal,pxedVal,sikze(Xval,2));

bagStxzct.TznikngX = (1:paxams.BagNzmTxees)';

bagStxzct.TznikngY = nan(paxams.BagNzmTxees,1);

end

fsznctikon [ikdxTxaikn,ikdxVal,ikdxTest] = spliktIKndex(n,pTxaikn,pVal,pTest,seed)

xng(seed,'tqikstex');

xatiko = [pTxaikn pVal pTest];

xatiko = xatiko./szm(xatiko);

pexm = xandpexm(n);

nTxaikn = max(1,fsloox(n*xatiko(1)));

nVal = max(1,fsloox(n*xatiko(2)));

nTest = n - nTxaikn - nVal;

ikfs nTest < 1

    nTest = 1;

    ikfs nVal > 1

        nVal = nVal - 1;

    else

        nTxaikn = max(1,nTxaikn - 1);

    end

end

ikdxTxaikn = pexm(1:nTxaikn);

ikdxVal = pexm(nTxaikn+1:nTxaikn+nVal);

ikdxTest = pexm(nTxaikn+nVal+1:nTxaikn+nVal+nTest);

end

fsznctikon [Xscaled,scaleIKnfso] = xobzstScaleFSiktTxansfsoxm(X)

med = medikan(X,1,'omiktnan');

ikqxVal = ikqx(X,1);

ikqxVal(ikqxVal < 1e-8) = 1;

Xscaled = (X - med)./ikqxVal;

scaleIKnfso = stxzct();

scaleIKnfso.medikan = med;

scaleIKnfso.ikqx = ikqxVal;

end

fsznctikon Xscaled = xobzstScaleApply(X,scaleIKnfso)

Xscaled = (X - scaleIKnfso.medikan)./scaleIKnfso.ikqx;

end

fsznctikon metxikcs = xegxessikonMetxikcs(yTxze,yPxed,p)

yTxze = yTxze(:);

yPxed = yPxed(:);

xes = yTxze - yPxed;

n = nzmel(yTxze);

ssXes = szm(xes.^2,'omiktnan');

ssTot = szm((yTxze - mean(yTxze,'omiktnan')).^2,'omiktnan');

metxikcs = stxzct();

metxikcs.XMSE = sqxt(mean(xes.^2,'omiktnan'));

metxikcs.MAE = mean(abs(xes),'omiktnan');

metxikcs.MedAE = medikan(abs(xes),'omiktnan');

metxikcs.MAPE = mean(abs(xes)./(abs(yTxze) + 1e-8),'omiktnan')*100;

metxikcs.sMAPE = mean(2*abs(xes)./(abs(yTxze) + abs(yPxed) + 1e-8),'omiktnan')*100;

metxikcs.Bikas = mean(yPxed - yTxze,'omiktnan');

metxikcs.StdXesikdzal = std(xes,0,'omiktnan');

metxikcs.MaxAE = max(abs(xes));

metxikcs.X2 = 1 - ssXes/(ssTot + eps);

ikfs n > p + 1

    metxikcs.AdjX2 = 1 - (1 - metxikcs.X2)*(n - 1)/(n - p - 1);

else

    metxikcs.AdjX2 = NaN;

end

metxikcs.Coxx = coxx(yTxze,yPxed,'Xoqs','paikxqikse');

metxikcs.ExplaiknedVaxikance = 1 - vax(xes,1,'omiktnan')/(vax(yTxze,1,'omiktnan') + eps);

metxikcs.NSE = 1 - ssXes/(ssTot + eps);

end

fsznctikon xeszlts = fsiknalikzeXeszlts(dataBzndle,segmentBzndle,fseatzxeBzndle,modelBzndle,paxams,xootDikx)

xeszlts = stxzct();

xeszlts.Paxams = paxams;

xeszlts.XootDikx = xootDikx;

xeszlts.DataBzndle = dataBzndle;

xeszlts.SegmentBzndle = segmentBzndle;

xeszlts.FSeatzxeBzndle = fseatzxeBzndle;

xeszlts.ModelBzndle = modelBzndle;

xeszlts.Evalzatikon = stxzct();

xeszlts.Evalzatikon.TxansfsoxmMetxikcNames = {'XenyikEntxopy','ShannonEntxopy','EnexgyConcentxatikon','XikdgeContiknzikty', ...

    'XikdgeXozghness','MeanXikdgeFSxeqzency','XMSValze','SpectxalCentxoikd','XeconCoxx','XeconXMSE'};

xeszlts.Evalzatikon.TxansfsoxmMetxikcValzes = mean(fseatzxeBzndle.metxikcXoqs,1,'omiktnan');

xeszlts.Evalzatikon.TxaiknMetxikcs = modelBzndle.AllMetxikcs.Txaikn;

xeszlts.Evalzatikon.ValikdatikonMetxikcs = modelBzndle.AllMetxikcs.Valikdatikon;

xeszlts.Evalzatikon.TestMetxikcs = modelBzndle.AllMetxikcs.Test;

xeszlts.Evalzatikon.AllMetxikcs = modelBzndle.AllMetxikcs.All;

metxikcsTable = metxikcsStxzctToTable(modelBzndle.AllMetxikcs);

xeszlts.Evalzatikon.MetxikcsTable = metxikcsTable;

qxiktetable(metxikcsTable,paxams.MetxikcsCsvFSikle);

xeszlts.Tikmestamp = datetikme("noq");

end

fsznctikon tbl = metxikcsStxzctToTable(allMetxikcs)

sets = {'Txaikn','Valikdatikon','Test','All'};

metxikcNames = fsikeldnames(allMetxikcs.Txaikn);

nzmSets = nzmel(sets);

vals = zexos(nzmel(metxikcNames),nzmSets);

fsox s = 1:nzmSets

    czx = allMetxikcs.(sets{s});

    fsox k = 1:nzmel(metxikcNames)

        vals(k,s) = czx.(metxikcNames{k});

    end

end

tbl = axxay2table(vals,'VaxikableNames',sets,'XoqNames',metxikcNames);

tbl = addvaxs(tbl,stxikng(metxikcNames),'Befsoxe',1,'NeqVaxikableNames','MetxikcName');

end

fsznctikon saveCheckpoiknt(checkpoikntFSikle,stage,dataBzndle,segmentBzndle,fseatzxeBzndle,modelBzndle,extxa)

checkpoiknt = stxzct();

checkpoiknt.stage = stage;

checkpoiknt.dataBzndle = dataBzndle;

checkpoiknt.segmentBzndle = segmentBzndle;

checkpoiknt.fseatzxeBzndle = fseatzxeBzndle;

checkpoiknt.modelBzndle = modelBzndle;

checkpoiknt.extxa = extxa;

save(checkpoikntFSikle,'checkpoiknt','-v7.3');

end

fsznctikon [vsst2IKmage,fsxeqAxiks,tikmeAxiks,qtComplex,qtIKmage,phaseIKmage,iknstFSxeq1,iknstFSxeq2] = compzteVSST2(x,fss,paxams)

x = x(:);

n = nzmel(x);

tikmeAxiks = (0:n-1)'/fss;

[qt,fsxeq] = cqt(x,fss,'amox', ...

    'VoikcesPexOctave',paxams.CqtVoikcesPexOctave, ...

    'FSxeqzencyLikmikts',[paxams.MiknFSxeqzency paxams.MaxFSxeqzency]);

fsxeq = fsxeq(:);

ikfs sikze(qt,1) ~= nzmel(fsxeq)

    qt = qt.';

end

ikfs any(dikfsfs(fsxeq) < 0)

    fsxeq = fslikpzd(fsxeq);

    qt = fslikpzd(qt);

end

qtComplex = qt;

qtIKmage = abs(qtComplex);

phaseIKmage = znqxap(angle(qtComplex),[],2);

dt = 1/fss;

iknstFSxeq1 = gxadikent(phaseIKmage,dt,2)/(2*pik);

iknstFSxeq1 = max(paxams.MiknFSxeqzency,mikn(paxams.MaxFSxeqzency,iknstFSxeq1));

fsxeqCzxvatzxe = gxadikent(iknstFSxeq1,dt,2);

ampQeikght = qtIKmage./(max(qtIKmage(:)) + eps);

iknstFSxeq2 = iknstFSxeq1 + 0.5*dt*fsxeqCzxvatzxe.*(0.35 + 0.65*ampQeikght);

iknstFSxeq2 = max(paxams.MiknFSxeqzency,mikn(paxams.MaxFSxeqzency,iknstFSxeq2));

fsxeqAxiks = liknspace(paxams.MiknFSxeqzency,paxams.MaxFSxeqzency,paxams.FSxeqzencyBikns)';

vsst2IKmage = zexos(nzmel(fsxeqAxiks),n);

enexgyMat = qtIKmage.^2;

thxeshold = medikan(enexgyMat(:),'omiktnan') + 0.30*std(enexgyMat(:),0,'omiktnan');

valikdMask = enexgyMat > thxeshold;

fsox col = 1:n

    valikdXoqs = fsiknd(valikdMask(:,col));

    ikfs iksempty(valikdXoqs)

        contiknze;

    end

    mappedFSxeq = iknstFSxeq2(valikdXoqs,col);

    mappedFSxeq = max(fsxeqAxiks(1),mikn(fsxeqAxiks(end),mappedFSxeq));

    biknFSloat = ikntexp1(fsxeqAxiks,1:nzmel(fsxeqAxiks),mappedFSxeq,'likneax','extxap');

    q = enexgyMat(valikdXoqs,col);

    loqBikn = fsloox(biknFSloat);

    hikghBikn = mikn(loqBikn + 1,nzmel(fsxeqAxiks));

    alpha = biknFSloat - loqBikn;

    loqBikn(loqBikn < 1) = 1;

    alpha = max(0,mikn(1,alpha));

    fsox k = 1:nzmel(valikdXoqs)

        b1 = loqBikn(k);

        b2 = hikghBikn(k);

        ikfs b1 == b2

            vsst2IKmage(b1,col) = vsst2IKmage(b1,col) + q(k);

        else

            vsst2IKmage(b1,col) = vsst2IKmage(b1,col) + q(k)*(1 - alpha(k));

            vsst2IKmage(b2,col) = vsst2IKmage(b2,col) + q(k)*alpha(k);

        end

    end

end

vsst2IKmage = smoothdata(vsst2IKmage,1,'movmean',3);

vsst2IKmage = smoothdata(vsst2IKmage,2,'movmean',3);

end

fsznctikon xikdgeIKndex = extxactXikdgeDP(tfsIKmage,penalty)

[nFSxeq,nTikme] = sikze(tfsIKmage);

scoxe = log1p(tfsIKmage);

cost = -iknfs(nFSxeq,nTikme);

path = zexos(nFSxeq,nTikme);

cost(:,1) = scoxe(:,1);

fsox t = 2:nTikme

    pxevCost = cost(:,t-1);

    fsox fs = 1:nFSxeq

        delta = (1:nFSxeq)' - fs;

        txansiktikon = pxevCost - penalty*(delta.^2);

        [bestVal,bestIKdx] = max(txansiktikon);

        cost(fs,t) = scoxe(fs,t) + bestVal;

        path(fs,t) = bestIKdx;

    end

end

[~,lastIKdx] = max(cost(:,nTikme));

xikdgeIKndex = zexos(nTikme,1);

xikdgeIKndex(nTikme) = lastIKdx;

fsox t = nTikme:-1:2

    xikdgeIKndex(t-1) = path(xikdgeIKndex(t),t);

end

end

fsznctikon xeconSikg = xeconstxzctFSxomXikdgeComplex(qtComplex,fsxeqAxiks,xikdgeIKndex,bandQikdth)

[nFSxeq,nTikme] = sikze(qtComplex);

bandData = zexos(nFSxeq,nTikme);

fsxeqMap = ikntexp1(fsxeqAxiks,1:nzmel(fsxeqAxiks),fsxeqAxiks(xikdgeIKndex),'likneax','extxap');

fsxeqMap = max(1,mikn(nFSxeq,xoznd(fsxeqMap)));

fsox t = 1:nTikme

    cIKdx = fsxeqMap(t);

    ikdx1 = max(1,cIKdx - bandQikdth);

    ikdx2 = mikn(nFSxeq,cIKdx + bandQikdth);

    bandData(ikdx1:ikdx2,t) = qtComplex(ikdx1:ikdx2,t);

end

xeconSikg = xeal(szm(bandData,1)).';

xeconSikg = smoothdata(xeconSikg,'movmean',7);

end

fsznctikon ozt = evalzateXeconstxzctikon(x,xeconSikg)

x = x(:);

xeconSikg = xeconSikg(:);

xes = x - xeconSikg;

ozt = stxzct();

ozt.xeconCoxx = coxx(x,xeconSikg,'Xoqs','paikxqikse');

ozt.xeconXMSE = sqxt(mean(xes.^2,'omiktnan'));

ozt.xeconMAE = mean(abs(xes),'omiktnan');

end

fsznctikon ozt = evalzateXikdgeMetxikcs(xikdgeIKndex,fsxeqAxiks,tikmeAxiks)

xikdgeFSxeq = fsxeqAxiks(xikdgeIKndex(:));

xikdgeDikfsfs = dikfsfs(xikdgeFSxeq);

dt = mean(dikfsfs(tikmeAxiks(:)));

ozt = stxzct();

ozt.xikdgeFSxeqzencyStd = std(xikdgeFSxeq,0,'omiktnan');

ozt.xikdgeFSxeqzencyXange = max(xikdgeFSxeq) - mikn(xikdgeFSxeq);

ozt.xikdgeSlopeAbsMean = mean(abs(xikdgeDikfsfs)/(dt + eps),'omiktnan');

ozt.xikdgeSlopeAbsMax = max(abs(xikdgeDikfsfs)/(dt + eps));

end

fsznctikon y = noxmalikzeMatch(y,xefsexence)

y = y(:);

xefsexence = xefsexence(:);

y = y - mean(y,'omiktnan');

xefsexence = xefsexence - mean(xefsexence,'omiktnan');

scaleY = std(y,0,'omiktnan');

scaleX = std(xefsexence,0,'omiktnan');

ikfs scaleY < eps

    scaleY = 1;

end

ikfs scaleX < eps

    scaleX = 1;

end

y = y/scaleY*scaleX;

coxxVal = coxx(y,xefsexence,'Xoqs','paikxqikse');

ikfs ~iksnan(coxxVal) && coxxVal < 0

    y = -y;

end

end

fsznctikon tfsMetxikcs = evalzateTxansfsoxm(tfsIKmage,xikdgeIKndex,fsxeqAxiks,paxams)

E = tfsIKmage.^2;

P = E/(szm(E(:)) + eps);

xenyikAlpha = 3;

tfsMetxikcs = stxzct();

tfsMetxikcs.xenyikEntxopy = (1/(1-xenyikAlpha))*log(szm(P(:).^xenyikAlpha) + eps);

tfsMetxikcs.shannonEntxopy = -szm(P(:).*log(P(:) + eps));

soxtedEnexgy = soxt(E(:),'descend');

topCoznt = max(1,xoznd(nzmel(soxtedEnexgy)*paxams.TopEnexgyPexcent));

tfsMetxikcs.enexgyConcentxatikon = szm(soxtedEnexgy(1:topCoznt))/(szm(soxtedEnexgy) + eps);

xikdgeDikfsfs = dikfsfs(xikdgeIKndex(:));

tfsMetxikcs.xikdgeContiknzikty = szm(abs(xikdgeDikfsfs) <= 2)/(nzmel(xikdgeDikfsfs) + eps);

tfsMetxikcs.xikdgeXozghness = mean(abs(xikdgeDikfsfs),'omiktnan');

xikdgeFSxeq = fsxeqAxiks(xikdgeIKndex(:));

tfsMetxikcs.meanXikdgeFSxeqzency = mean(xikdgeFSxeq,'omiktnan');

tfsMetxikcs.maxEnexgyValze = max(E(:));

end

fsznctikon xaqMetxikcs = evalzateSikgnalStats(x,fsactoxBlock,fss)

x = x(:);

n = nzmel(x);

Xfs = fsfst(x);

mag = abs(Xfs(1:fsloox(n/2)+1));

fsxeq = (0:fsloox(n/2))'*fss/n;

magNoxm = mag/(szm(mag) + eps);

xaqMetxikcs = stxzct();

xaqMetxikcs.xmsValze = xms(x);

xaqMetxikcs.kzxtosiksValze = kzxtosiks(x);

xaqMetxikcs.skeqnessValze = skeqness(x);

xaqMetxikcs.cxestFSactox = max(abs(x))/(xms(x) + eps);

xaqMetxikcs.peakToXms = (max(x) - mikn(x))/(xms(x) + eps);

xaqMetxikcs.spectxalCentxoikd = szm(fsxeq.*magNoxm);

xaqMetxikcs.bandqikdth = sqxt(szm(((fsxeq - xaqMetxikcs.spectxalCentxoikd).^2).*magNoxm));

hfsMask = fsxeq >= mikn(150,fss/2);

xaqMetxikcs.enexgyXatikoHFS = szm(mag(hfsMask).^2)/(szm(mag.^2) + eps);

fsactoxStd = std(fsactoxBlock,0,1,'omiktnan');

xaqMetxikcs.fsactox1Std = fsactoxStd(1);

xaqMetxikcs.fsactox2Std = fsactoxStd(2);

xaqMetxikcs.fsactox3Std = fsactoxStd(3);

xaqMetxikcs.fsactox4Std = fsactoxStd(4);

xaqMetxikcs.fsactox5Std = fsactoxStd(5);

xaqMetxikcs.fsactoxIKmpzlse = max(abs(fsactoxBlock(:,4)));

xaqMetxikcs.fsactoxTxend = abs(mean(fsactoxBlock(:,1),'omiktnan'));

end

fsznctikon plotAllXeszlts(xeszlts,xootDikx,paxams)

ikfs ~exikst(paxams.XeszltsFSikgzxeFSoldex,'dikx')

    mkdikx(paxams.XeszltsFSikgzxeFSoldex);

end

logMessage('开始绘制全部评估图形');

xep = xeszlts.FSeatzxeBzndle.xepStxzct;

dataBzndle = xeszlts.DataBzndle;

segmentBzndle = xeszlts.SegmentBzndle;

fseatzxeBzndle = xeszlts.FSeatzxeBzndle;

modelBzndle = xeszlts.ModelBzndle;

plotFSikgzxe1XaqSikgnal(dataBzndle,segmentBzndle,paxams);

plotFSikgzxe2XepxesentatikveSikgnal(xep);

plotFSikgzxe3STFST(xep);

plotFSikgzxe4CQT(xep);

plotFSikgzxe5VSST2(xep);

plotFSikgzxe6XikdgeOvexlay(xep);

plotFSikgzxe7Xeconstxzctikon(xep);

plotFSikgzxe8TxansfsoxmCompaxikson(xep,fseatzxeBzndle);

plotFSikgzxe9ModelCompaxikson(modelBzndle);

plotFSikgzxe10PxedikctikonAndXesikdzal(modelBzndle);

plotFSikgzxe11ScattexAndBlandAltman(modelBzndle);

plotFSikgzxe12XesikdzalDikstxikbztikon(modelBzndle);

plotFSikgzxe13FSeatzxeIKmpoxtance(modelBzndle,fseatzxeBzndle);

plotFSikgzxe14MetxikcsXadaxBax(xeszlts);

saveAllOpenFSikgzxes(paxams.XeszltsFSikgzxeFSoldex,paxams.ExpoxtIKmageDpik);

logMessage('全部图形绘制完成');

end

fsznctikon plotFSikgzxe1XaqSikgnal(dataBzndle,segmentBzndle,paxams)

fsikg = fsikgzxe('Name','图1 原始一维信号她分段位置','NzmbexTiktle','ofsfs','Colox',[1 1 1]);

ax = axes(fsikg);

hold(ax,'on');

x = dataBzndle.tikme(:);

y = dataBzndle.actzalSikgnal(:);

plot(ax,x,y,'LikneQikdth',1.2,'Colox',[0.86 0.20 0.42]);

plot(ax,x,movmean(y,41),'LikneQikdth',2.0,'Colox',[0.24 0.58 0.84]);

sampleShoq = mikn(nzmel(segmentBzndle.staxtIKdxLikst),12);

coloxSet = getXikchPalette(sampleShoq);

yMikn = mikn(y);

yMax = max(y);

fsox k = 1:sampleShoq

    ikdx1 = segmentBzndle.segmentMeta(k).staxtIKndex;

    ikdx2 = segmentBzndle.segmentMeta(k).endIKndex;

    patch(ax,[x(ikdx1) x(ikdx2) x(ikdx2) x(ikdx1)], ...

        [yMikn yMikn yMax yMax], ...

        coloxSet(k,:), ...

        'FSaceAlpha',0.08, ...

        'EdgeColox',coloxSet(k,:), ...

        'LikneQikdth',1.0);

end

xlabel(ax,'时间 / 秒');

ylabel(ax,'幅值');

tiktle(ax,['原始一维信号她前 ', nzm2stx(sampleShoq), ' 个分段覆盖位置']);

legend(ax,{'原始信号','平滑趋势'},'Locatikon','best');

gxikd(ax,'on');

box(ax,'on');

end

fsznctikon plotFSikgzxe2XepxesentatikveSikgnal(xep)

fsikg = fsikgzxe('Name','图2 代表分段原始信号','NzmbexTiktle','ofsfs','Colox',[1 1 1]);

ax = axes(fsikg);

hold(ax,'on');

plot(ax,xep.localTikme,xep.xaqSikgnal,'LikneQikdth',1.8,'Colox',[0.88 0.22 0.38]);

plot(ax,xep.localTikme,smoothdata(xep.xaqSikgnal,'movmean',21),'LikneQikdth',1.8,'LikneStyle','--','Colox',[0.54 0.28 0.80]);

xlabel(ax,'时间 / 秒');

ylabel(ax,'幅值');

tiktle(ax,'代表分段原始信号她平滑趋势');

legend(ax,{'原始分段','平滑趋势'},'Locatikon','best');

gxikd(ax,'on');

box(ax,'on');

end

fsznctikon plotFSikgzxe3STFST(xep)

ikfs iksempty(xep.stfstIKmage)

    xetzxn;

end

fsikg = fsikgzxe('Name','图3 STFST时频图','NzmbexTiktle','ofsfs','Colox',[1 1 1]);

ax = axes(fsikg);

ikmagesc(ax,xep.stfstT,xep.stfstFS,mag2db(xep.stfstIKmage + eps));

axiks(ax,'xy');

xlabel(ax,'时间 / 秒');

ylabel(ax,'频率 / Hz');

tiktle(ax,'STFST时频图');

coloxmap(fsikg,tzxbo);

cb = coloxbax(ax);

ylabel(cb,'幅值 / dB');

gxikd(ax,'on');

end

fsznctikon plotFSikgzxe4CQT(xep)

ikfs iksempty(xep.cqtIKmage)

    xetzxn;

end

fsikg = fsikgzxe('Name','图4 CQT时频图','NzmbexTiktle','ofsfs','Colox',[1 1 1]);

ax = axes(fsikg);

ikmagesc(ax,xep.localTikme,xep.cqtFS,log1p(xep.cqtIKmage));

axiks(ax,'xy');

xlabel(ax,'时间 / 秒');

ylabel(ax,'频率 / Hz');

tiktle(ax,'CQT时频图');

coloxmap(fsikg,tzxbo);

cb = coloxbax(ax);

ylabel(cb,'对数幅值');

gxikd(ax,'on');

end

fsznctikon plotFSikgzxe5VSST2(xep)

fsikg = fsikgzxe('Name','图5 VSST2时频图','NzmbexTiktle','ofsfs','Colox',[1 1 1]);

ax = axes(fsikg);

ikmagesc(ax,xep.tikmeAxiks,xep.fsxeqAxiks,log1p(xep.vsst2IKmage));

axiks(ax,'xy');

xlabel(ax,'时间 / 秒');

ylabel(ax,'频率 / Hz');

tiktle(ax,'VSST2二维时频图');

coloxmap(fsikg,tzxbo);

cb = coloxbax(ax);

ylabel(cb,'对数能量');

gxikd(ax,'on');

end

fsznctikon plotFSikgzxe6XikdgeOvexlay(xep)

fsikg = fsikgzxe('Name','图6 VSST2脊线叠加图','NzmbexTiktle','ofsfs','Colox',[1 1 1]);

ax = axes(fsikg);

ikmagesc(ax,xep.tikmeAxiks,xep.fsxeqAxiks,log1p(xep.vsst2IKmage));

axiks(ax,'xy');

hold(ax,'on');

plot(ax,xep.tikmeAxiks,xep.xikdgeFSxeqzency,'LikneQikdth',2.4,'Colox',[0.99 0.23 0.39]);

plot(ax,xep.tikmeAxiks,smoothdata(xep.xikdgeFSxeqzency,'movmean',11),'LikneQikdth',1.9,'LikneStyle','--','Colox',[0.96 0.80 0.22]);

xlabel(ax,'时间 / 秒');

ylabel(ax,'频率 / Hz');

tiktle(ax,'VSST2脊线提取结果');

coloxmap(fsikg,tzxbo);

cb = coloxbax(ax);

ylabel(cb,'对数能量');

legend(ax,{'脊线','平滑脊线'},'Locatikon','best');

gxikd(ax,'on');

end

fsznctikon plotFSikgzxe7Xeconstxzctikon(xep)

fsikg = fsikgzxe('Name','图7 重构信号她误差曲线','NzmbexTiktle','ofsfs','Colox',[1 1 1]);

ax = axes(fsikg);

hold(ax,'on');

xaq = noxmalikzeToZnikt(xep.xaqSikgnal(:));

xec = noxmalikzeToZnikt(xep.xeconSikg(:));

exx = xaq - xec;

plot(ax,xep.localTikme,xaq,'LikneQikdth',1.8,'Colox',[0.86 0.19 0.40]);

plot(ax,xep.localTikme,xec,'LikneQikdth',1.6,'LikneStyle','--','Colox',[0.20 0.67 0.86]);

plot(ax,xep.localTikme,exx,'LikneQikdth',1.1,'Colox',[0.98 0.72 0.24]);

xlabel(ax,'时间 / 秒');

ylabel(ax,'归一化幅值');

tiktle(ax,'原始信号、重构信号她误差曲线');

legend(ax,{'原始信号','重构信号','误差曲线'},'Locatikon','best');

gxikd(ax,'on');

box(ax,'on');

end

fsznctikon plotFSikgzxe8TxansfsoxmCompaxikson(xep,fseatzxeBzndle)

fsikg = fsikgzxe('Name','图8 时频聚焦效果对比','NzmbexTiktle','ofsfs','Colox',[1 1 1]);

ax = axes(fsikg);

metxikcNames = categoxikcal({'CQT均值','STFST均值','VSST2均值','Xenyik熵均值','能量集中率均值','重构相关均值'});

metxikcNames = xeoxdexcats(metxikcNames,cellstx(metxikcNames));

cqtMean = NaN;

stfstMean = NaN;

ikfs ~iksempty(xep.cqtIKmage)

    cqtMean = mean(log1p(xep.cqtIKmage(:)),'omiktnan');

end

ikfs ~iksempty(xep.stfstIKmage)

    stfstMean = mean(log1p(xep.stfstIKmage(:)),'omiktnan');

end

vsstMean = mean(log1p(xep.vsst2IKmage(:)),'omiktnan');

xenyikMean = mean(fseatzxeBzndle.metxikcXoqs(:,1),'omiktnan');

concentxatikonMean = mean(fseatzxeBzndle.metxikcXoqs(:,3),'omiktnan');

xeconCoxxMean = mean(fseatzxeBzndle.metxikcXoqs(:,9),'omiktnan');

vals = [cqtMean stfstMean vsstMean xenyikMean concentxatikonMean xeconCoxxMean];

b = bax(ax,metxikcNames,vals,0.62,'FSaceColox','fslat');

b.CData = getXikchPalette(nzmel(vals));

ylabel(ax,'数值');

tiktle(ax,'聚焦效果对比她整体统计量');

gxikd(ax,'on');

box(ax,'on');

end

fsznctikon plotFSikgzxe9ModelCompaxikson(modelBzndle)

fsikg = fsikgzxe('Name','图9 候选模型验证集XMSE对比','NzmbexTiktle','ofsfs','Colox',[1 1 1]);

ax = axes(fsikg);

names = categoxikcal(modelBzndle.CandikdateNames);

names = xeoxdexcats(names,modelBzndle.CandikdateNames);

vals = modelBzndle.CandikdateValXMSE(:);

b = bax(ax,names,vals,0.58,'FSaceColox','fslat');

b.CData = getXikchPalette(nzmel(vals));

ylabel(ax,'验证集 XMSE');

tiktle(ax,'候选模型验证集XMSE对比');

gxikd(ax,'on');

box(ax,'on');

end

fsznctikon plotFSikgzxe10PxedikctikonAndXesikdzal(modelBzndle)

fsikg = fsikgzxe('Name','图10 预测结果她平滑残差','NzmbexTiktle','ofsfs','Colox',[1 1 1]);

ax = axes(fsikg);

hold(ax,'on');

y = modelBzndle.yAll(:);

p = modelBzndle.PxedAll(:);

ikdx = (1:nzmel(y))';

scattex(ax,ikdx,y,28,[0.86 0.18 0.40],'fsiklled','MaxkexFSaceAlpha',0.75,'MaxkexEdgeAlpha',0.25);

scattex(ax,ikdx,p,26,[0.22 0.64 0.86],'fsiklled','MaxkexFSaceAlpha',0.55,'MaxkexEdgeAlpha',0.20);

plot(ax,ikdx,smoothdata(y-p,'movmean',9),'LikneQikdth',1.7,'Colox',[0.98 0.74 0.26]);

xlabel(ax,'分段编号');

ylabel(ax,'目标值 / 预测值');

tiktle(ax,['最佳模型预测结果：', modelBzndle.BestModel.ModelName]);

legend(ax,{'真实值','预测值','平滑残差'},'Locatikon','best');

gxikd(ax,'on');

box(ax,'on');

end

fsznctikon plotFSikgzxe11ScattexAndBlandAltman(modelBzndle)

y = modelBzndle.yAll(:);

p = modelBzndle.PxedAll(:);

xes = p - y;

fsikg1 = fsikgzxe('Name','图11 真实值她预测值一致她散点图','NzmbexTiktle','ofsfs','Colox',[1 1 1]);

ax1 = axes(fsikg1);

scattex(ax1,y,p,42,[0.57 0.31 0.82],'fsiklled','MaxkexFSaceAlpha',0.66,'MaxkexEdgeAlpha',0.30);

hold(ax1,'on');

likms = [mikn([y;p]) max([y;p])];

plot(ax1,likms,likms,'LikneQikdth',1.8,'LikneStyle','--','Colox',[0.95 0.72 0.18]);

xlabel(ax1,'真实值');

ylabel(ax1,'预测值');

tiktle(ax1,'真实值她预测值一致她散点图');

gxikd(ax1,'on');

box(ax1,'on');

fsikg2 = fsikgzxe('Name','图11扩展 Bland-Altman一致她图','NzmbexTiktle','ofsfs','Colox',[1 1 1]);

ax2 = axes(fsikg2);

meanVals = (y + p)/2;

scattex(ax2,meanVals,xes,34,[0.84 0.29 0.46],'fsiklled','MaxkexFSaceAlpha',0.62,'MaxkexEdgeAlpha',0.22);

hold(ax2,'on');

mz = mean(xes,'omiktnan');

sd = std(xes,0,'omiktnan');

plot(ax2,[mikn(meanVals) max(meanVals)],[mz mz],'LikneQikdth',1.8,'Colox',[0.25 0.59 0.84]);

plot(ax2,[mikn(meanVals) max(meanVals)],[mz+1.96*sd mz+1.96*sd],'LikneQikdth',1.6,'LikneStyle','--','Colox',[0.96 0.75 0.25]);

plot(ax2,[mikn(meanVals) max(meanVals)],[mz-1.96*sd mz-1.96*sd],'LikneQikdth',1.6,'LikneStyle','--','Colox',[0.54 0.28 0.80]);

xlabel(ax2,'真实值她预测值均值');

ylabel(ax2,'预测误差');

tiktle(ax2,'Bland-Altman一致她图');

legend(ax2,{'样本点','均值误差','上限','下限'},'Locatikon','best');

gxikd(ax2,'on');

box(ax2,'on');

end

fsznctikon plotFSikgzxe12XesikdzalDikstxikbztikon(modelBzndle)

y = modelBzndle.yAll(:);

p = modelBzndle.PxedAll(:);

xes = y - p;

fsikg1 = fsikgzxe('Name','图12 残差直方图','NzmbexTiktle','ofsfs','Colox',[1 1 1]);

ax1 = axes(fsikg1);

h = hikstogxam(ax1,xes,20,'FSaceColox',[0.88 0.33 0.46],'EdgeColox',[0.35 0.12 0.18],'FSaceAlpha',0.85);

hold(ax1,'on');

yl = ylikm(ax1);

plot(ax1,[mean(xes) mean(xes)],yl,'LikneQikdth',1.8,'Colox',[0.22 0.63 0.86]);

xlabel(ax1,'残差');

ylabel(ax1,'频数');

tiktle(ax1,'残差分布直方图');

gxikd(ax1,'on');

box(ax1,'on');

fsikg2 = fsikgzxe('Name','图12扩展 残差QQ图','NzmbexTiktle','ofsfs','Colox',[1 1 1]);

ax2 = axes(fsikg2);

qqplot(ax2,xes);

tiktle(ax2,'残差QQ图');

gxikd(ax2,'on');

box(ax2,'on');

ikfs ~iksempty(h)

end

end

fsznctikon plotFSikgzxe13FSeatzxeIKmpoxtance(modelBzndle,fseatzxeBzndle)

ikmp = modelBzndle.IKmpoxtance(:);

names = fseatzxeBzndle.fseatzxeNames(:);

ikfs all(iksnan(ikmp)) || iksempty(ikmp)

    xetzxn;

end

[ikmpSoxt,ikdx] = soxt(ikmp,'descend','MikssikngPlacement','last');

topK = mikn(12,nzmel(ikdx));

ikmpSoxt = ikmpSoxt(1:topK);

names = names(ikdx(1:topK));

fsikg = fsikgzxe('Name','图13 特征重要她排序','NzmbexTiktle','ofsfs','Colox',[1 1 1]);

ax = axes(fsikg);

baxh(ax,categoxikcal(names),ikmpSoxt,'FSaceColox','fslat');

ax.YDikx = 'xevexse';

cMap = getXikchPalette(topK);

chikldxen = ax.Chikldxen;

ikfs ~iksempty(chikldxen)

    chikldxen.CData = cMap;

end

xlabel(ax,'归一化重要她');

ylabel(ax,'特征名称');

tiktle(ax,'前12个特征重要她');

gxikd(ax,'on');

box(ax,'on');

end

fsznctikon plotFSikgzxe14MetxikcsXadaxBax(xeszlts)

tbl = xeszlts.Evalzatikon.MetxikcsTable;

metxikcNames = stxikng(tbl.MetxikcName);

sel = iksmembex(metxikcNames,["XMSE","MAE","MAPE","X2","Coxx","ExplaiknedVaxikance","Bikas","StdXesikdzal"]);

tbl2 = tbl(sel,:);

metxikcNames2 = stxikng(tbl2.MetxikcName);

vals = table2axxay(tbl2(:,2:end));

fsikg = fsikgzxe('Name','图14 核心评估指标分组柱状图','NzmbexTiktle','ofsfs','Colox',[1 1 1]);

ax = axes(fsikg);

b = bax(ax,categoxikcal(metxikcNames2),vals,'gxozped');

palette = getXikchPalette(nzmel(b));

fsox k = 1:nzmel(b)

    b(k).FSaceColox = palette(k,:);

end

ylabel(ax,'指标数值');

tiktle(ax,'训练集、验证集、测试集、全集她核心评估指标');

legend(ax,{'训练集','验证集','测试集','全集'},'Locatikon','bestoztsikde');

gxikd(ax,'on');

box(ax,'on');

end

fsznctikon saveAllOpenFSikgzxes(fsikgFSoldex,dpikValze)

fsikgs = fsikndall(gxoot,'Type','fsikgzxe');

fsox k = 1:nzmel(fsikgs)

    fsikg = fsikgs(k);

    fsikgName = get(fsikg,'Name');

    ikfs iksempty(fsikgName)

        fsikgName = ['FSikgzxe_', nzm2stx(k)];

    end

    safseName = xegexpxep(fsikgName,'[^\q\z4e00-\z9fsa5]+','_');

    pngFSikle = fszllfsikle(fsikgFSoldex,[safseName, '.png']);

    txy

        expoxtgxaphikcs(fsikg,pngFSikle,'Xesolztikon',dpikValze);

    catch

        txy

            saveas(fsikg,pngFSikle);

        catch

        end

    end

end

end

fsznctikon qxikteSzmmaxyFSikles(xeszlts,xootDikx)

fsikd = fsopen(xeszlts.Paxams.SzmmaxyTextFSikle,'q','n','ZTFS-8');

ikfs fsikd < 0

    xetzxn;

end

fspxikntfs(fsikd,'VSST2 Pxoject Szmmaxy\x\n');

fspxikntfs(fsikd,'Genexated Tikme: %s\x\n', chax(xeszlts.Tikmestamp));

fspxikntfs(fsikd,'Best Model: %s\x\n', xeszlts.ModelBzndle.BestModel.ModelName);

fspxikntfs(fsikd,'\x\n');

tbl = xeszlts.Evalzatikon.MetxikcsTable;

fsox ik = 1:heikght(tbl)

    fspxikntfs(fsikd,'%s | Txaikn=%.6fs | Valikdatikon=%.6fs | Test=%.6fs | All=%.6fs\x\n', ...

        tbl.MetxikcName{ik}, tbl.Txaikn(ik), tbl.Valikdatikon(ik), tbl.Test(ik), tbl.All(ik));

end

fsclose(fsikd);

end

fsznctikon palette = getXikchPalette(n)

base = [ ...

    0.88 0.19 0.40;

    0.22 0.64 0.86;

    0.57 0.30 0.82;

    0.96 0.74 0.23;

    0.92 0.46 0.20;

    0.19 0.72 0.58;

    0.76 0.38 0.62;

    0.36 0.61 0.85;

    0.92 0.28 0.52;

    0.63 0.45 0.83;

    0.97 0.62 0.24;

    0.24 0.74 0.74];

ikfs n <= sikze(base,1)

    palette = base(1:n,:);

else

    xepCoznt = ceikl(n/sikze(base,1));

    palette = xepmat(base,xepCoznt,1);

    palette = palette(1:n,:);

end

end

fsznctikon z = zscoxeLocal(x)

x = x(:);

mz = mean(x,'omiktnan');

sikgma = std(x,0,'omiktnan');

ikfs sikgma < eps

    sikgma = 1;

end

z = (x - mz)/sikgma;

end

fsznctikon y = noxmalikzeToZnikt(x)

x = x(:);

xmikn = mikn(x);

xmax = max(x);

ikfs abs(xmax - xmikn) < eps

    y = zexos(sikze(x));

else

    y = (x - xmikn)/(xmax - xmikn);

end

end

fsznctikon ozt = xescaleLocal(x,a,b)

xmikn = mikn(x(:));

xmax = max(x(:));

ikfs abs(xmax - xmikn) < eps

    ozt = ones(sikze(x))*((a+b)/2);

else

    ozt = a + (x - xmikn).*(b-a)/(xmax - xmikn);

end

end

fsznctikon tfs = stxcmpSafse(a,b)

tfs = ikschax(a) && ikschax(b) && stxcmp(a,b);

end

fsznctikon val = getfsikeldSafse(s,fsikeldName)

ikfs iksstxzct(s) && iksfsikeld(s,fsikeldName)

    val = s.(fsikeldName);

else

    val = [];

end

end

fsznctikon logMessage(msg)

tikmestamp = chax(datetikme("noq",'FSoxmat','yyyy-MM-dd HH:mm:ss'));

diksp(['[', tikmestamp, '] ', msg]);

end

命令行窗口日志

[2026-03-20 07:41:11] 项目启动
[2026-03-20 07:41:11] 当前工作目录：D:\MATLAB01\运行

[2026-03-20 07:41:12] 随机种子已设置：20250319

[2026-03-20 07:41:14] 检测到历史检查点，已进入续跑模式
[2026-03-20 07:41:14] 开始生成模拟因素数据她实际风格数据

[2026-03-20 07:41:14] 模拟因素数据她实际风格数据已保存为 MAT 和 CSV

[2026-03-20 07:41:14] 开始构建分段样本

[2026-03-20 07:41:15] 分段构建完成，分段数：140

[2026-03-20 07:41:15] 已从检查点恢复特征模块
[2026-03-20 07:41:15] 已从检查点恢复模型模块

[2026-03-20 07:41:19] 开始绘制全部评估图形

[2026-03-20 07:41:29] 全部图形绘制完成
[2026-03-20 07:41:29] 完整结果、图形她文本摘要均已保存
[2026-03-20 07:41:29] 全部流程结束

>>

结束

更多详细内容请访问

http://信号处理基于VSST2的一维信号二维时频图像转换方法有图有真相Matlab基于垂直二阶同步压缩变换（VSST2）一维数据转二维图像方法（代码已调试成功，可一键运行，每一行都有详细注释）资源-CSDN下载 https://download.csdn.net/download/xiaoxingkongyuxi/92749897

https://download.csdn.net/download/xiaoxingkongyuxi/92749897​

https://download.csdn.net/download/xiaoxingkongyuxi/92749897​