椭圆规/tuoyuangui

AI每周总结-地球物理（2026-W41）

Sun, 11 Oct 2026 00:00:00 GMT

AI每周总结 · 地球物理（2026-W41：2026-10-05 ~ 2026-10-11）

项目对象 project：调度器仍未注入 {{project}}，沿用默认口径 AI + 深度学习 + HPC + 地震数据处理 + 全波形反演（FWI）

📌 分类口径（本期起生效）：AI/地球物理 = 以深度学习/机器学习/神经网络/生成模型等为核心创新；传统方法 = 以物理/数学/数值/信号处理/反演/成像/层析等为核心，不以 DL/ML 为主要创新。

本周期两类条数分布：28 条位（主榜 10 + 补遗 6 + 延伸观察 12）中 AI/地球物理 19 条、传统方法 9 条。主窗口主榜原 10 条中传统方法仅 1 条（Q-FWI），为满足"传统约 4 条"配比，从延伸观察升入 3 条可验证的传统方法条目（TREMOR、SPECFEM3D 转动分量扩展、5D Radon 内存高效插值），另将断档补遗中的 B5（BFBM3D）在索引中标注为传统方法候选——升入原因与可信度逐条注明，未凑数。

一、本周概览

项	值
覆盖区间（ISO）	2026-10-05 ~ 2026-10-11（2026-W41）
实际采集日	1 天（10-08）
日报实际检索窗口	2026-10-01 ~ 2026-10-08
条目位	28 条（主榜 10 + 断档补遗 6 + 延伸观察 12）
两类分布（条位）	AI/地球物理 19 / 传统方法 9（主榜 9:1；补遗 4:2；延伸观察 6:6——延伸观察是传统方法的富集区，与 W39 结论"期刊侧是传统方法富矿"同源）
⚠️ 采集缺口	W40（09-28 ~ 10-04）无日报；10-09 ~ 10-11 无采集；上期日报为 09-25，间隔 13 天
去重情况	主榜 10 条中有 2 条为跨期重复/同方向（SDI 范式再表述、SeisDiff-FNO 方向重复）
可复现资产	GeoFWI3D 数据 DOI `10.5281/zenodo.20148778`（CC BY 4.0，已实测可解析）；⚠️ 配套代码地址未获取
开源地震栈	Devito v4.8.23 / 2026-08-07、ObsPy 1.5.1 / 2026-08-28、SeisBench v0.12.0 / 2026-06-24——连续四期无新版本（本次为双周复查日，实测确认）
来源结构	主榜 6/10 来自正式期刊；补遗 6/6 全部来自期刊——延续 W39 的"期刊侧主导"结论

二、本周主线（5 条；每条标注所涉类别）

主线 1 ·【AI/地球物理】隐式/生成式 FWI 从"提出方法"转向"工程化改良"，共同特征是"低/零额外成本"

主榜 10 条里有 6 条落在这一带（全部为 AI 线）：

条目	改良点	额外成本
C2F-IFWI（主榜 #3，arXiv 2610.01081）	多分辨率哈希由粗到精激活	零额外参数
摄动式 IFWI（补遗 B1，10.1093/gji/ggag403）	参数分解 + 坐标归一化	不改结构
谱归一化替代 WGAN-GP 梯度惩罚（主榜 #6，10.1093/gji/ggag418）	省掉插值采样	更省
REG（主榜 #5，arXiv 2610.05371）	稳健集成引导：weighting + clipping	零额外 denoiser / forward 评估
扩散先验做正则（主榜 #2，10.1029/2025jh001223）	替换正则项	不改主干
Prior-free ISI（主榜 #7，10.1093/gji/ggag406）	连续表示降计算负担	去掉先验依赖

判断：这个领域已经过了"堆大模型"的阶段，正在进入**"如何把已有的生成式/隐式表示接进物理流程而不炸"**的阶段。这恰好是与工程条件最匹配的一段。

主线 2 ·【AI/地球物理·基础设施】基础设施终于出现：GeoFWI3D 大规模 3D 基准数据集

主榜 #1 GeoFWI3D（arXiv 2610.01033，2026-10-01，License CC BY 4.0）是本期、也是近 6 期以来第一个真正的大规模 3D 基准数据集。

团队：UT Austin + LANL + Uppsala + KFUPM（⚠️ 详见第八节）
数据：DOI 10.5281/zenodo.20148778（✅ 已实测可解析）
Technical Validation 章节把 4.5 Data-Driven Surrogate for Traveltime and Wavefield Prediction 与 4.6 Training 3D Diffusion Models 列为正式技术验证任务——说明"神经算子做正演代理 + 扩散模型做速度建模"已从单点方法变成基准数据集要评测的能力项。
⚠️ 论文第 6 节 "Code availability" 在 arXiv HTML 中为空，未解析出代码 URL；数据集体量/格式未验证。这是本期的最高优先级挂账项。

与 W39 的 SPBench 互补：SPBench 说的是"评测不规范"，GeoFWI3D 提供的是"可以用来规范评测的东西"。

主线 3 ·【AI/地球物理】扩散模型在地球物理里的角色已分化成三种

角色	代表条目	说明
① 生成器 / 先验	主榜 #2（10.1029/2025jh001223，KAUST）、#5（REG）	沿既有路线
② 正则化器	主榜 #2（替换正则项）	—
③ 多尺度特征提取器	补遗 B4 DiffClassNet（10.1093/gji/ggag383）	拿中间噪声水平的特征做分类

判断：只把扩散模型当"又一个生成式反演器"会低估它。第三种用法（用扩散中间层的噪声水平特征做分类）在监督信号稀缺时尤其有用。

主线 4 ·【传统方法·HPC】HPC 侧继续薄弱，但本期"最接近真 HPC"的三条全部是传统方法线

本窗口内没有一条以"大规模并行 / GPU 内核 / 显存优化"为主贡献的地震条目——但最接近的三条全部为传统方法，且都在延伸观察里：
- TREMOR（分布式模板匹配，12× 加速且保证结果等价，传统·HPC 系统）——本期已升入精选榜（见第三节）
- 5D Radon 内存高效群稀疏插值（避免物化完整 5D 数组——与 W39 的"内存而非 FLOPs"判据同源，传统·信号处理/HPC）——本期已升入精选榜
- SPECFEM3D 转动分量扩展（谱元法数值方法，传统·数值）——本期已升入精选榜
叠加开源栈连续四期零 release（Devito / ObsPy / SeisBench，本次双周复查日实测确认）。
结论仍然是：HPC 能力需要自建，不能等上游。 且与 W39 一致——HPC 增量主要出现在传统方法线。

这解释了为什么本期主榜里"零额外算力开销"的方法改良特别密集——整个领域都在算力受限下找便宜的涨点方式。

主线 5 ·【两类通用】来源结构与诚实性问题

期刊侧主导（延续 W39 的判断）：主榜 10 条中 6 条来自正式期刊（JGR ML&C ×2、GJI ×2、Interpretation ×1、Geophysics ×1 计在补遗），4 条来自 arXiv；补遗 6 条全部来自期刊。
⚠️ 一个必须提醒自己的诚实性问题：本期主榜 10 条中，只有 1 条（REG）给出了可直接引用的量化数字（PSNR +6.2–8.2 dB、NS 误差 −26.4%）；其余各条的收益表述几乎全是定性的（"faster""more accurate""more robust""promising"）。 这意味着本期的"进展"更像方向确认而非性能突破，任何基于这些条目做的选型决策都应该以自复现为准，不要直接引用摘要里的形容词。
传统方法条目在延伸观察中富集（6/12），与其进主榜与否无关地持续产出——说明"传统方法没死"，只是在本窗口的 AI 检索口径下被挤到观察区。

三、本周精选 Top 10（AI/地球物理 6 条 + 传统方法 4 条，整体按相关性排序）

配比说明：主窗口主榜原 10 条经归类后为 AI 9 条 + 传统 1 条（Q-FWI）。传统方法可验证条目不足 4 条的原因：① 本周仅一个采集点、检索窗口仅 8 天；② 检索口径以"AI + 地球物理"为主，传统方法条目自然富集在延伸观察区。处理方式：从延伸观察升入 3 条可验证性较高的传统方法条目（TREMOR、SPECFEM3D 转动分量、5D Radon）补足 4 条配比，升入条目的完整字段转述自日报延伸观察节、未做新推断；被顶出的 3 条 AI 条目（Camie 油田、CRG 去混叠、谱归一化 GAN）移入提名区，信息无损失。断档补遗中的 B5（BFBM3D）同为传统方法，因窗口归属问题保留在补遗节并标注类别。

1. ⭐ GeoFWI3D：面向深度学习辅助地震成像的大规模三维速度模型数据集

类别：AI/地球物理（基准数据集，服务于 DL 地震成像）
作者/团队：UT Austin + LANL + Uppsala + KFUPM（⚠️ 见第八节）
链接：arXiv 2610.01033（v1，2026-10-01，physics.geo-ph，CC BY 4.0）· https://arxiv.org/abs/2610.01033
方法/内容：大规模 3D 速度模型数据集；Technical Validation 章节将"数据驱动代理做走时/波场预测"与"训练 3D 扩散模型"列为正式验证任务。
数据：Zenodo DOI 10.5281/zenodo.20148778（✅ 已实测可解析；⚠️ 体量/格式未验证）
代码：⚠️ 论文第 6 节 "Code availability" 在 arXiv HTML 中为空 → 未获取
对本项目的启发：最高价值的一条。 它把"神经算子做正演代理 + 扩散做速度建模"从单点方法抬升为基准要评测的能力项；与 SPBench 构成"评测规范 / 可评测对象"的互补组合。建议作为3D 代理模型与扩散 VMB 的统一评测底座。
验证状态：✅ arXiv 元数据 + 数据 DOI 可解析性实测；⚠️ 代码地址未获取（最高优先级挂账）、数据集体量与格式未验证。

2. 扩散先验 + 神经算子的 time-lag 图像速度建模

类别：AI/地球物理（扩散先验 + 神经算子）
作者/团队：KAUST（Ma / Taufik / Alkhalifah）
链接：JGR: Machine Learning and Computation · https://doi.org/10.1029/2025jh001223（published [2026,10]，published-online 2026-10-03，Crossref created 2026-10-03）
方法：以 time-lag 图像为条件，用神经算子增强的扩散先验做速度模型建立；明确做了 synthetic 与 field data 两个层面。
数据：合成 + 实测（详见全文）。
代码：未声明（⚠️）。
对本项目的启发：是 W39 期 09-23 #1（扩散式由浅到深 VMB）的"可核验落地版本"——给出完整摘要 + 完整机构 + 上线日期，比 09-23 那条更可核验。建议作为扩散 VMB 的对照基线与复现目标。
验证状态：✅ 期刊/DOI/机构/上线日期经 Crossref 核验；⚠️ 量化数值需读全文。

3. ⭐ REG：面向科学反问题的稳健集成引导

类别：AI/地球物理（生成式反演器的后处理层）
作者/团队：⚠️ 机构未验证（HTML 404，API 无 affiliation）
链接：arXiv 2610.05371（v1，2026-10-04，cs.LG）· https://arxiv.org/abs/2610.05371
方法：面向"已训练好的生成式反演器"的零成本后处理层——通过 weighting + clipping 稳健化集成引导。
数据：科学反问题基准（黑洞成像场景；详见全文）。
量化（本期唯一一条给出可引用数字的条目）：黑洞场景 PSNR +6.2–8.2 dB，NS 误差 −26.4%。
代码：未验证（⚠️）。
对本项目的启发：核心卖点是不额外调用 denoiser / forward model——属于"采样器外科手术"式工作（前 5 期未见此类）。若已有训练好的扩散反演器，这是一层几乎零成本可直接加的后处理。 建议先在小规模 FWI 扩散先验上做可行性验证。
验证状态：⚠️ 机构未验证、代码未验证；数字为作者自述。

4. TREMOR：面向大规模地震数据集合的分布式模板匹配

类别：传统方法（分布式系统 / 数据序列处理；无学习组件）【自延伸观察升入，升入原因见配比说明】
作者/团队：Manos Chatzakis、Rodrigo Flores-Allende、Mikael Freire、Yoann Cano、Léonard Seydoux、Themis Palpanas
链接：arXiv 2610.02534（2026-10-01，cs.DB）· https://arxiv.org/abs/2610.02534
方法：分布式数据序列处理框架，处理超出单机内存的波形集合，用于大规模模板匹配。
数据/量化：比最佳竞速方法快达 12×，且返回完全相同（exact）的结果。
代码：未验证（⚠️）。
对本项目的启发：本期 HPC 侧最有价值的一条。 "exact same results + 12×" 这类保证等价的加速，在大规模模板匹配上是硬需求；其分布式序列处理架构对"超出单机内存的地震数据集合"场景有直接参考价值。
验证状态：✅ arXiv 元数据与作者列表核验（转述自日报延伸观察节）；⚠️ 12× 为作者自述，代码未验证。

5. C2F-IFWI：隐式全波形反演的多分辨率哈希由粗到精编码

类别：AI/地球物理（隐式神经表示 INR）
作者/团队：Linrong Wang / Shaowen Wang / Fan Min / Alkhalifah（⚠️ KAUST 由同组已出版论文反推确证，见第八节）
链接：arXiv 2610.01081（v1，2026-10-01，physics.geo-ph）· https://arxiv.org/abs/2610.01081
方法：对隐式神经表示（INR）采用由粗到精的多分辨率哈希激活调度，不增加任何可训练参数。
数据：FWI 基准（详见全文）。
代码：未声明（⚠️）。
对本项目的启发：本期"IFWI 工程化改良"三条正交路线之一，卖点是零额外参数——在算力受限场景下这是最友好的一类涨点方式。
验证状态：⚠️ 脚注 1（Linrong Wang、Fan Min）机构未解析；代码未声明；量化收益未验证。

6. Robust 5D 地震数据插值：内存高效群稀疏 Radon 变换

类别：传统方法（信号处理 / 反演；ℓ1-ℓ1 群稀疏优化，无 DL）【自延伸观察升入，升入原因见配比说明】
作者/团队：Ji Li（University of Calgary）、Dawei Liu（Xi'an Jiaotong University）
链接：Geophysics · https://doi.org/10.1190/geo-2025-0371（created 2026-10-07）
方法：ℓ1-ℓ1 最小化 + 强群稀疏（沿慢度轴把 Radon 系数分入不重叠组 + 基于能量的贪婪选组）；关键工程贡献是内存高效实现：不构造完整 5D Radon 立方体，而是跨频率片顺序累加群能量，只对被选中的组更新系数。
数据/量化：合成数据上优于 POCS 与阻尼秩缩减（DRR）（⚠️ 具体指标需读全文）。
代码：未声明（⚠️）。
对本项目的启发："避免物化完整 5D 数组"是典型的 HPC 内存优化模式，与我们在大规模 FWI 上的显存/内存压力同源，与 W39 的"内存而非 FLOPs"判据同源——方法论可直接迁移。
验证状态：✅ 期刊/DOI/作者机构核验（转述自日报延伸观察节）；⚠️ 量化对比数字需读全文。

7. 共成像点道集（CIG）的自注意力 summary network 做速度建模

类别：AI/地球物理（自注意力 + conditional flow matching）
作者/团队：Georgia Tech（Herrmann 组）
链接：arXiv 2610.09282（v1，2026-10-07，cs.LG / physics.geo-ph，CC BY 4.0）· https://arxiv.org/abs/2610.09282
方法：用自注意力 summary network 从 CIG 提取摘要统计量，配合 conditional flow matching 做速度建模。
数据：速度建模基准（详见全文）。
代码：未声明（⚠️）。
对本项目的启发：把 CIG 从"诊断量"升格为"条件变量"——这是本期新增方向之一，且与 W38 的 09-15 #2（CIG 条件化扩散联合反演）形成同一条线的延续。
验证状态：✅ arXiv 元数据与许可核验；⚠️ 量化结果需读全文。

8. 谱元法扩展：转动地震动的直接模拟（SPECFEM3D 扩展）

类别：传统方法（谱元法数值模拟；无 DL）【自延伸观察升入，升入原因见配比说明】
作者/团队：Anjali C. Dhabu、Aida Hejazi Nooghabi、Céline Hadziioannou
链接：arXiv 2610.09568（2026-10-07）· https://arxiv.org/abs/2610.09568
方法：扩展 SPECFEM3D，在 Gauss-Lobatto-Legendre 积分点上由位移空间梯度直接计算转动地震动；提出 PGRR 图（类比 PGV 图）。
数据：印度河-恒河盆地 3D 模型——证明低速沉积层显著放大并重新分布转动地震动。
代码：⚠️ 未验证（若为 SPECFEM3D 扩展实现，与谱元法波场模拟栈可能有接口价值）。
对本项目的启发：谱元法正演的数值扩展，直接服务于 SPECFEM3D 生态——若项目使用谱元法栈，这是近期少见的直接相关条目；同时是"传统数值方法持续产出"的又一例证。
验证状态：✅ arXiv 元数据核验（转述自日报延伸观察节）；⚠️ 代码可用性未验证。

9. Prior-free ISI：连续表示的无先验隐式地震反演

类别：AI/地球物理（隐式连续表示）
作者/团队：中国海洋大学
链接：Geophysical Journal International · https://doi.org/10.1093/gji/ggag406（published-online 2026-10-05，created 2026-10-01）
方法：用**连续表示（continuous representation）**做无需先验的隐式地震反演，降低计算负担。
数据：地震反演基准（详见全文）。
代码：未声明（⚠️）。
对本项目的启发："去掉先验依赖"这个方向对跨工区迁移最友好——不需要为每个新工区准备先验/预训练权重。
验证状态：✅ 期刊/DOI/机构核验；⚠️ 量化收益未验证、代码未声明。

10. 多参数黏弹性全波形反演（Q-FWI）用于 CO₂ 饱和度监测

类别：传统方法（黏弹性多参数 FWI；无 DL）
作者/团队：UT Austin + SINTEF
链接：Interpretation · https://doi.org/10.1190/int-2025-1037（published-online 2026-10-07）
方法：多参数黏弹性 FWI 定量反演 CO₂ 饱和度。
数据：Sleipner OBN（北海 CCS 示范场地）。
代码：未声明（⚠️）。
对本项目的启发：前 5 期 FWI 应用侧多为油气，CCUS 定量化为新增方向。若涉及碳封存监测，这是本周唯一直接相关条目，且用的是公开示范场地（Sleipner）。
验证状态：✅ 期刊/DOI/机构核验；⚠️ 量化精度与饱和度误差未验证。

断档补遗（2026-09-26 ~ 2026-09-30，主榜窗口之外的 5 天；含类别列）

因上期日报为 09-25、本期为 10-08，中间 13 天存在采集断档。日报第二节单列了这 5 天的 6 条期刊产出，本文件完整继承。

序	条目	类别	来源	日期（published）
B1 ⭐	Perturbation-Based Implicit FWI with Improved Optimization Conditioning（摄动式 IFWI + 坐标归一化；中国海洋大学；测缺失低频）断档期最相关	AI	https://doi.org/10.1093/gji/ggag403	2026-09-30
B2	Unsupervised erratic noise suppression in prestack gathers via PnP-ADMM with implicit neural representation（Calgary；⚠️ 机构著录存疑）	AI（PnP + INR）	https://doi.org/10.1190/geo-2026-1753	2026-09-30
B3	Quasi-Global Search Behaviour of Large-Step Gradient-Based Optimization in FWI（KAUST）	传统（优化方法）	https://doi.org/10.1111/1365-2478.70265	2026-09-29
B4	Generative Diffusion Models for Geophysical Classification Problems（DiffClassNet；UT Austin BEG）	AI	https://doi.org/10.1093/gji/ggag383	2026-09-28
B5	Seismic Random Noise Suppression Based on Block Flattening BM3D（BFBM3D；中国地质大学武汉）	传统（BM3D 变体去噪）	https://doi.org/10.1111/1365-2478.70262	2026-09-27
B6	Probabilistic inversion of electromagnetic data using Stein variational gradient descent（SVGD；MIT + Houston）	传统（贝叶斯数值反演）	https://doi.org/10.1093/gji/ggag392	2026-09-26

⚠️ 补遗而非并入主榜的原因：这 6 条的实际上线日落在 2026-09-26 ~ 09-30，属于 W40（09-28 ~ 10-04） 与前一周的交界，不在本期主窗口（10-01 ~ 10-08）内。按周报口径，它们的"应归周"是 W39 末 / W40 初，但因为 W40 无日报，只能在 W41 文件中以补遗形式保存。这是本文件最需要注意的口径点。

若按"应归周"（W39 末 / W40 初）口径统计两类分布，断档补遗为 AI 3 条 + 传统 3 条——传统方法在断档期期刊侧的产出密度与 W39 结论一致。

本周提名区（被顶出主榜及延伸观察剩余条目；标注类别）

序	条目	类别	来源	备注
11	深度学习在大规模地震干扰压制中的实际应用：安哥拉 Camie 油田案例（345 km² 真实工区）	AI	arXiv 2610.09663	被顶出主榜；⚠️ 机构未验证、处理时间数字未给出（需取 PDF）
12	相邻 CRG 辅助多步深度学习框架做地震去混叠（同济大学）	AI	10.1029/2026jh001391	被顶出主榜；期刊/DOI/机构核验 ✅
13	基于谱归一化对抗学习的无监督物理约束速度反演（吉大+ETH+Harvard+浙大）	AI	10.1093/gji/ggag418	被顶出主榜；期刊/DOI/机构核验 ✅
14	Twist Flow for Inverse Problems（Georgia Tech，Herrmann 组）	AI	arXiv 2610.09281	与 #7 同组同日；针对"后验欠覆盖/模态畸变"，与 REG 互补
15	Multi-Modal Surface Wave Inversion using Physics Guided VAE（UT Austin BEG）	AI	arXiv 2610.02337	物理引导 VAE + Grad-CAM 解释 latent
16	SeisDiff-FNO: FNO + 条件扩散做地震数据增强（KFUPM + KAUST）	AI	10.1016/j.aiig.2026.100280	Crossref/OpenAlex 均无摘要，仅方向信号
17	ISF-Unet：轻量 3D 地震断层分割网络（中国石油大学（北京）克拉玛依校区）	AI	10.1190/int-2025-1008	F3 / Kerry3D / 准噶尔盆地实际数据
18	Conformal Prediction for Earthquake Early Warning（CQR 90% 名义下达 90.03% 覆盖）	AI	10.1093/gji/ggag415	本期唯一给出"覆盖率达标"硬数字的 UQ 工作
19	多区域深度学习框架做低频地震检测（Kyoto University DPRI；Guerrero 地震空区 OBS）	AI	10.1029/2026jh001455	"跨 6 构造域训练 → 单域标定 → 应用"三段式
20	DeepStratNet：稀疏标注下的地震层位追踪（改分割为有界坐标回归）	AI	arXiv 2610.02494	机构未验证
21	AI 辅助地质建模的条件化与解释工作流（Horizon Europe GO-Forward 项目）	AI	arXiv 2610.09871	工业界"成熟度"表态
22	开源地震栈双周复查：Devito / ObsPy / SeisBench 均无新 release（连续四期）	传统（基础设施）	GitHub Releases API 实测（2026-10-08）	下次复查日 2026-10-22

四、本周全量条目索引（28 条位；含类别列）

类别标注为本文件按"分类口径"对日报内容的重新归类，不改变日报原文。

主榜 10 条（窗口 2026-10-01 ~ 10-08）

#	条目	类别	链接
1	GeoFWI3D: Large-scale 3D Velocity Model Dataset for DL-assisted Seismic Imaging	AI	https://arxiv.org/abs/2610.01033
2	Diffusion Priors Enhanced VMB From Time-Lag Images Using a Neural Operator	AI	https://doi.org/10.1029/2025jh001223
3	Coarse-to-fine multi-resolution hash encoding for implicit FWI（C2F-IFWI）	AI	https://arxiv.org/abs/2610.01081
4	Self-attention summary networks for subsurface VMB from CIGs	AI	https://arxiv.org/abs/2610.09282
5	Robust Ensemble Guidance for Scientific Inverse Problems（REG）	AI	https://arxiv.org/abs/2610.05371
6	Unsupervised physics-constrained velocity inversion based on spectral normalization adversarial learning	AI	https://doi.org/10.1093/gji/ggag418
7	Prior-free implicit seismic inversion with continuous representation（ISI）	AI	https://doi.org/10.1093/gji/ggag406
8	Multi-Parameter Viscoelastic FWI (Q-FWI) for CO2 Saturation Monitoring	传统	https://doi.org/10.1190/int-2025-1037
9	Seismic Deblending via an Adjacent-CRG-Assisted Multistep DL Framework	AI	https://doi.org/10.1029/2026jh001391
10	Real-world application of DL in large-scale seismic interference attenuation（Camie field, Angola）	AI	https://arxiv.org/abs/2610.09663

断档补遗 6 条（2026-09-26 ~ 09-30）

#	条目	类别	链接
B1	Perturbation-Based Implicit FWI with Improved Optimization Conditioning ⭐	AI	https://doi.org/10.1093/gji/ggag403
B2	Unsupervised erratic noise suppression via PnP-ADMM with implicit neural representation	AI	https://doi.org/10.1190/geo-2026-1753
B3	Quasi-Global Search Behaviour of Large-Step Gradient-Based Optimization in FWI	传统	https://doi.org/10.1111/1365-2478.70265
B4	Generative Diffusion Models for Geophysical Classification Problems（DiffClassNet）	AI	https://doi.org/10.1093/gji/ggag383
B5	Seismic Random Noise Suppression Based on Block Flattening BM3D（BFBM3D）	传统	https://doi.org/10.1111/1365-2478.70262
B6	Probabilistic inversion of electromagnetic data using SVGD	传统	https://doi.org/10.1093/gji/ggag392

延伸观察 12 条（未进主榜，供追踪；其中 3 条已升入精选榜）

#	条目	类别	链接
1	Twist Flow for Inverse Problems（Georgia Tech）	AI	arXiv 2610.09281
2	Multi-Modal Surface Wave Inversion using Physics Guided VAE（UT Austin BEG）	AI	arXiv 2610.02337
3	TREMOR: Template Matching for Large Seismic Data Collections（⭐ 已升入精选榜 #4）	传统	arXiv 2610.02534
4	Spectral Element Extension for Direct Simulation of Rotational Ground Motions（⭐ 已升入精选榜 #8）	传统	arXiv 2610.09568
5	SeisDiff-FNO（FNO + 条件扩散）	AI	10.1016/j.aiig.2026.100280
6	Robust 5D seismic data interpolation via memory-efficient group sparse Radon transform（⭐ 已升入精选榜 #6）	传统	10.1190/geo-2025-0371
7	ISF-Unet：轻量 3D 断层分割	AI	10.1190/int-2025-1008
8	Conformal Prediction for Earthquake Early Warning	AI	10.1093/gji/ggag415
9	开源地震栈双周复查（无新 release，连续四期）	传统（基础设施）	GitHub Releases API
10	多区域 DL 框架做低频地震检测（Kyoto DPRI）	AI	10.1029/2026jh001455
11	DeepStratNet：稀疏标注层位追踪	AI	arXiv 2610.02494
12	AI 辅助地质建模工作流（Horizon Europe 项目）	AI	arXiv 2610.09871

五、本周演化：重复 / 升级 / 新增方向（分两线）

5.A AI/地球物理线

重复（本期检索再次命中）

条目	前期位置	本期判定
Structure-Driven Methodology: An Emerging Cross-Domain Paradigm（arXiv 2610.02698，2026-10-02）	W39 期 09-21 主榜 #1（Structure-Driven Inversion，传统范式线）	同一"结构驱动"范式的再表述，判定为重复，不进主榜
SeisDiff-FNO（10.1016/j.aiig.2026.100280）	与 W39 期 09-24 主榜 #2「高低频协同 FNO 三维声波场」同属 FNO + 地震方向	方向重复；且本期因拿不到摘要而方法未验证，维持延伸观察

升级（前期"信号"→ 本期拿到可核验的新证据）

09-24 主榜 #2「高低频协同 FNO 三维声波场」→ 本期升级为"有基准支撑的方向"。 本期 GeoFWI3D 在 Technical Validation 章节中把 4.5 Data-Driven Surrogate for Traveltime and Wavefield Prediction 与 4.6 Training 3D Diffusion Models 列为正式的技术验证任务。
09-23 主榜 #1「扩散式由浅到深速度建模」→ 本期出现同类范式的可核验落地版本。 JGR ML&C 的 10.1029/2025jh001223（KAUST）给出完整摘要 + 完整机构 + 上线日期，并明确做了 synthetic 与 field data 两个层面。
隐式 FWI（IFWI）从"零星出现"升级为"本期主线"。 前 5 期 IFWI 只是偶发；本期一次性出现 3 条相互正交的 IFWI 改进：多分辨率哈希由粗到精（主榜 #3）、摄动参数化（补遗 B1）、GAN 谱归一化（主榜 #6）。

本周新增方向

🆕 大规模 3D 速度模型开源基准数据集（GeoFWI3D）——前 5 期主榜从未有"数据集/基准"类条目排在首位。
🆕 IFWI 的"由粗到精哈希激活"与"摄动参数化"——两条都不增加可训练参数、都是参数化层面的改动。
🆕 面向"已训练好的生成式反演器"的零成本后处理层（REG 的 weighting + clipping；另有 Twist Flow 的 likelihood 侧坐标）——前 5 期未见此类"采样器外科手术"式工作。
🆕 把 CIG（共成像点道集）从诊断量升格为条件变量（self-attention summary network + conditional flow matching）。

5.B 传统方法线

重复

无本期新重复（上期传统线条目未在本窗口再次命中；SPBench 项目页仍挂账未复查——SPBench 本身为 AI 线）。

升级

"内存而非 FLOPs"判据（W39 传统 HPC 线结论）在本期获得第三条独立佐证：5D Radon 内存高效实现（避免物化完整 5D 数组）。该判据的跨周证据链现为：W39（TorchFDTD、Kokkos、Diff-NekRS、分布式 SVGD）→ W41（5D Radon）。
开源栈生态的数值扩展仍在推进（SPECFEM3D 转动分量扩展），尽管官方 release 连续四期零更新——"工具链低活跃 ≠ 方法侧停滞"。

本周新增方向

🆕 黏弹性 Q-FWI 用于 CCUS 饱和度定量（Interpretation，UT Austin + SINTEF）——前 5 期 FWI 应用侧多为油气，CCUS 定量化为新增。
🆕 保证结果等价的大规模分布式模板匹配（TREMOR，12× 且 exact）——区别于此前"近似加速"类 HPC 条目。
🆕 谱元法直接模拟转动地震动（PGRR 图）——转动分量模拟首次进入本系列视野。

5.C 两线交叉观察

传统方法在延伸观察区富集（6/12），与 W39"期刊侧是传统方法富矿"结论同源——延伸观察的来源同样以期刊为主（5D Radon〔Geophysics〕、SPECFEM 扩展〔arXiv〕、开源栈复查〔GitHub 实测〕）。
断档补遗的 6 条中传统方法占 3 条（B3 大步长优化、B5 BFBM3D、B6 SVGD 电磁）——断档期的期刊产出延续 W39 的传统方法密度。
AI 线的"零成本改良"主线（主线 1）与传统线的"内存工程"主线（主线 4）是同一算力约束的两面：前者绕开算力需求，后者降低算力需求。

六、本周趋势总结（分两线）

6.A AI/地球物理线

本期最突出的信号：隐式/生成式 FWI 从"提出方法"转向"工程化改良"，且改良的共同特征是"低/零额外成本"。 主榜 10 条中 6 条落在此带。领域已过"堆大模型"阶段，进入"如何把已有的生成式/隐式表示接进物理流程而不炸"的阶段。
第二条主线：基础设施终于出现。 GeoFWI3D 与 SPBench 互补——前者提供可用来规范评测的东西，后者指出评测不规范。
第三条：扩散模型在地球物理里的角色已分化成三种（生成器/先验、正则化器、多尺度特征提取器）。只当"又一个生成式反演器"会低估它。
⚠️ 诚实性问题：本期主榜 10 条中只有 1 条给出可直接引用的量化数字。 其余各条收益表述几乎全是定性的。这意味着本期的"进展"更像方向确认而非性能突破。

6.B 传统方法线

传统方法条目在延伸观察区富集（6/12），且本期"最接近真 HPC"的三条全部是传统方法线（TREMOR 分布式模板匹配、5D Radon 内存高效、SPECFEM3D 扩展）。叠加开源栈连续四期零 release，HPC 能力仍需自建。
"内存而非 FLOPs"判据获得跨周第三、四条独立佐证（5D Radon 避免物化完整数组；TREMOR 处理超出单机内存的集合）——该判据已可视为传统 HPC 线的稳定结论。
CCUS 定量化（Q-FWI + Sleipner OBN）为传统 FWI 应用侧的新增方向——与 AI 线无关，纯物理建模能力驱动的扩展。
断档期（09-26~09-30）期刊产出中传统方法占一半（B3/B5/B6），再次印证"期刊侧是传统方法富矿"（W39 结论第三次成立）。

6.C 综合判断

本周两线产出比约 19:9（AI:传统），但主榜原序口径下为 9:1——传统方法在本期被"检索口径 + 单采集点 + 半周窗口"三重因素压到了延伸观察区。 升入 3 条后配比恢复为 6:4，但必须说明：这是整理动作对检索口径偏差的补偿，不是传统方法真实产出密度的下降。 事实上延伸观察 + 断档补遗中的传统方法条目数（9 条）与 AI 线的差距远小于主榜呈现的 9:1。

七、对项目的行动建议（本周）

课题口径仍为默认的 AI + HPC + 地震数据处理 + FWI。以下均为建议，未执行任何操作。括号内为所属线别。

A. 立即可做（低风险、低成本，1–3 天）

下载并核对 GeoFWI3D 数据体量——DOI 10.5281/zenodo.20148778 已实测可解析、CC BY 4.0。先确认体量与格式，再决定是否作为内部 3D 代理模型评测底座（AI 线）。
给现有扩散反演器加一层 REG 式 post-processing（weighting + clipping）做可行性验证——零额外 denoiser/forward 调用，是本周期性价比最高的一条工程化改良（AI 线）。
把 GeoFWI3D 的 Technical Validation 任务清单（4.5 走时/波场代理、4.6 3D 扩散）转成内部评测 checklist——它代表社区认可的"能力项"（AI 线）。
把 IFWI 三条正交改良（哈希激活 / 摄动参数化 / 谱归一化）列为对现有 INR 反演管线的可选改动，优先级按"改动量从小到大"排序（AI 线）。
在下次数据规整任务中评估"避免物化完整数组"模式（5D Radon 的跨频率片顺序累加）能否用于现有大规模数据体处理（传统/HPC 线）。

B. 需要评估（有收益但需先做可行性判断，1–4 周）

评估 Q-FWI 用于 CCUS 监测的可行性——Sleipner OBN 是公开示范场地，可先做数据可获取性调研（传统线）。
评估"Prior-free ISI"对跨工区迁移的价值——去掉先验依赖意味着不需要为每个新工区准备先验/预训练权重（AI 线）。
评估 CIG 作为条件变量的通用性（自注意力 summary network + flow matching），看能否接入现有速度建模流程（AI 线）。
评估 TREMOR 式"保证等价的分布式处理"对内部大规模波形任务的适用性——exact + 12× 的组合在需要可复现性的场景价值高（传统/HPC 线）。
评估 Camie 油田案例的处理时间收益——⚠️ 需先取 PDF，摘要未给出时间对比数字（AI 线）。

C. 仅记录（暂不投入）

Structure-Driven 范式的再次表述（arXiv 2610.02698，传统范式线）——已判定为重复，维持季度级跟踪。
SeisDiff-FNO（10.1016/j.aiig.2026.100280）（AI 线）——Crossref / OpenAlex 均无摘要，仅为方向信号，作者组合可信，可设提醒。
"Twist Flow 的 likelihood 侧坐标"（AI 线）——同属零成本后处理层，与 REG 一并跟踪。

D. HPC 侧的具体提醒

开源栈复查结论（本次为双周复查日）：Devito v4.8.23 / 2026-08-07；ObsPy 1.5.1 / 2026-08-28；SeisBench v0.12.0 / 2026-06-24——均无新版本，连续四期成立。下次到期复查日：2026-10-22。
"延伸观察中的 HPC 线索"单独建追踪列表——本期已通过"延伸观察升入精选榜"动作部分解决（TREMOR、5D Radon、SPECFEM 扩展进榜），后续每期延续该机制，避免传统 HPC 条目反复停留在观察区。
继续保持"内存而非 FLOPs"作为硬约束（5D Radon 避免物化完整 5D 数组，与 W39 判据同源，本期为第三条独立佐证）。

八、未解决项 / 需人工确认

8.1 本期新增的未验证项

#	条目	类别	缺口	建议处理
1	GeoFWI3D（2610.01033）	AI	论文第 6 节 "Code availability" 在 arXiv HTML 中为空，未解析出代码 URL；数据集体量/格式未验证	⭐ 最高优先级：取 PDF 版或联系通讯作者确认代码地址；下载后核对体量
2	C2F-IFWI（2610.01081）	AI	脚注 1（Linrong Wang、Fan Min）机构未解析	取 PDF 版看脚注；或按作者名检索机构主页
3	REG（2610.05371）	AI	机构未验证（HTML 404，API 无 affiliation）；代码未验证	等 arXiv 生成 HTML 后复查
4	TREMOR（2610.02534）	传统	12× 加速为作者自述；代码未验证	⚠️ 本条自延伸观察升入精选榜，升入依据为日报延伸观察节原文，量化数字未复核
5	5D Radon 插值（10.1190/geo-2025-0371）	传统	合成上"优于 POCS 与 DRR"的具体指标未给出	同上，升入依据为日报原文；量化数字需读全文
6	Camie 油田 SI 压制（2610.09663）	AI	机构未验证（HTML 404）；处理时间对比的具体数字未给出	同上；时间对比数字是本条最重要的信息，建议取 PDF
7	SeisDiff-FNO（10.1016/j.aiig.2026.100280）	AI	Crossref 与 OpenAlex 均无摘要，方法完全未验证	等全文上线；作者组合可信，可设提醒
8	10.1190/geo-2024-0841	—	与 geo-2026-1753 同标题，但 Crossref 摘要内容为"荔湾凹陷 OBS + 拖缆速度建模"，明显错配	判定为重复/错配记录，以 geo-2026-1753 为准；需人工在 SEG 平台确认
9	geo-2026-1753 机构著录存疑	AI（PnP-INR）	Crossref 把 Daniel Trad 标为西安交通大学，与其长期任职 Calgary 矛盾	疑似 affiliation 索引错位，需人工确认
10	JAG / C&G 多条（106382、106403、106406、106392、106415 等）	混合	Crossref 无摘要；且 `created` 为 2026-06/07、仅 `published` 落在 2026-10	日期口径存疑（可能是 10 月号而非 10 月新上线），故未进主榜。若需纳入，需人工到 Elsevier 平台确认上线日期

8.2 跨期悬置项（多日未解决，需人工介入）

SPBench 项目页 https://seismicprocessingbenchmark.github.io/SPBench/ —— W39 期 09-25 v2 已降级为每周复查，本期未复查，继续挂账。地址已由论文图注确证，页面未上线。
4 篇 Springer Applied Geophysics 条目仍需批量取 PDF：10.1007/s11770-026-1617-5（GPR FWI 初始模型，传统）、10.1007/s11770-026-1608-6（ViT 重力反演，AI）、10.1007/s11770-026-1616-6（Radon-FISTA，传统）、10.1007/s11770-026-1547-2（Kalman 走时反演，传统）。Springer 不提供结构化摘要，API 路径已走到尽头，只能人工取 PDF。
10.1007/s11770-026-1587-7（U-Net 三维重力反演）—— W39 期 09-25 v2 已建议停止跟踪，本期不再复查。
RSDB（10.1016/j.eqs.2026.06.001，全球 Raspberry Shake 波形数据集）—— 机构/摘要/数据地址全缺，日期口径冲突（published [2026,10] vs created 2026-09-23）。本期 Earthquake Science 扫描再次命中，仍未解决。
Agentic FWI 摘要（10.1007/s11004-026-10342-5）、Science China 生成式 AI 综述摘要（10.1007/s11430-025-2038-7）、伴随法小震矩释放率摘要（rs-3.rs-10679490/v1）、BicycleGAN 日期冲突（10.1016/j.cageo.2026.106272）——均跨期 ≥3 期未推进。

8.3 本周口径层面的新教训（务必记住）

教训	内容
⚠️ 断裂周期需单列补遗	上期 09-25、本期 10-08，间隔 13 天且中间 W40 无日报。处理口径：主榜严格按 7 天窗口编制，断档区间单列"补遗"，并标注其"应归周"是 W39 末 / W40 初。
⚠️ "同标题双 DOI"需主动查重	Geophysics 的 `geo-2024-0841` 与 `geo-2026-1753` 标题相同，但前者 Crossref 摘要实为"荔湾凹陷 OBS 速度建模" → 错配记录。下期对进主榜条目额外按标题做一次 Crossref 查重。
⭐ 传统方法配比不足时的处理范式（本期确立）	主窗口可验证传统条目不足 4 条时：① 从延伸观察升入可验证条目并逐条注明升入依据；② 断档补遗中的传统条目标注类别备用；③ 明确说明"不足原因"（检索口径偏向 AI + 单采集点），不凑数、不降验证标准。
⭐ 新路径：arXiv HTML 404 时用"同组已出版论文"的 Crossref 机构字段反推 affiliation	本期 2610.01081 的 KAUST 由同组 10.1111/1365-2478.70265（Shaowen Wang / Alkhalifah）确证。
Crossref 429 加剧	请求间隔需 ≥2.5 s + 3 次重试（1.2 s 不够）。
arXiv HTML 可用率下降	本窗口 12 篇中 7 篇 HTML 404 → 必须配 arXiv API `id_list` 兜底取摘要/作者。
期刊侧继续主导	主榜 6/10 来自期刊，补遗 6/6 全部来自期刊。再次确认 ISSN 区间扫描优先于 arXiv `cat:` 检索。

8.4 需人工确认的性能数字

本期主榜 10 条中只有 1 条（REG）给出可直接引用的量化数字（PSNR +6.2–8.2 dB、NS 误差 −26.4%）；其余 9 条摘要全是定性表述。升入精选榜的 TREMOR（12× exact）与 5D Radon（优于 POCS/DRR）同样为作者自述、未复核。已逐条在日报中标注，未做任何数字推测。

九、检索说明与本文件生成方式

本文件不是检索产物。生成过程为：读取 AI每日总结_2026-10-08.md（主榜 10 条 + 断档补遗 6 条 + 延伸观察 12 条）→ 按 ISO 周归入 W41 → 抽取该期的"〇对比""趋势总结""未解决项" → 按"AI/地球物理 + 传统方法"两分类重新归类并标注 → 因主窗口传统条目不足 4 条，自延伸观察升入 3 条可验证传统方法条目（TREMOR、SPECFEM3D 转动分量、5D Radon），被顶出的 3 条 AI 条目移入提名区 → 输出本文件。未访问任何外部数据源。
两类条数分布：28 条位中 AI/地球物理 19 条 / 传统方法 9 条（主榜 9:1；补遗 4:2；延伸观察 6:6）。精选 Top 10 配比 6:4。
⚠️ 传统方法不足 4 条的原因与处理：主窗口主榜原仅 1 条传统方法（Q-FWI）。原因有三：① 本周仅 10-08 一个采集点、窗口仅 8 天；② 日报检索口径以"AI + 地球物理"为主，传统条目天然富集于延伸观察；③ W40 整周空缺使断档期期刊产出（传统方法密度高的来源）只能以补遗形式存在。处理：从延伸观察升入 3 条（TREMOR / SPECFEM3D 扩展 / 5D Radon），全部为可验证条目、逐条注明升入依据；未凑数、未降低验证标准。
历史重复/升级/新增：重复 2 条（SDI 范式再表述〔传统〕、SeisDiff-FNO 方向重复〔AI〕）；升级 3 项（FNO 方向获基准支撑〔AI〕、扩散 VMB 获可核验版本〔AI〕、内存判据获第三条佐证〔传统〕）；新增方向 AI 线 4 项 + 传统线 3 项。
⚠️ 2026-10-08 变更：按用户要求，本期日报 AI每日总结_2026-10-08.md 已随全部 12 份历史日报移出主目录，现留存于工作区 .回收站_日报_2026-10-08/ 与外部备份 /home/liguolong/geo_scratch/backup_日报_2026-10-08/（删除前校验一致）。"回溯入口"请改到上述两处查阅。
⚠️ 本文件的覆盖不完整，需在下一期补齐的部分：
1. W40（09-28 ~ 10-04）整周无日报——该周的期刊产出（尤其 10-01 ~ 10-04 段）可能未被完整捕获；
2. W41 内 10-09 ~ 10-11 无采集；
3. 断档补遗 6 条的"应归周"是 W39 末 / W40 初，本文件仅为保存处，周口径上存在跨周漂移。 建议：下一期日报生成时，把检索窗口显式设为"自上期日报日至今"，避免再次出现 13 天断档。
归并口径声明：
- 周划分 = ISO 周（周一~周日）。
- 本周仅一个采集点，主榜原序不重排；精选榜为满足 6:4 配比做了一次重排（升入 + 顶出），已在配比说明中逐条注明。
诚实性声明：
- 所有链接、作者、机构、日期、数字均转述自日报原文；日报未验证的一律沿用"未验证/需人工确认"标注，本文件未做任何新推断或补齐。
- 日报中标为"企业新闻口径""二手来源""推断"的内容，在本文件中保持原标注。
front matter 说明：周报使用 tags / category 均为 "AI每周总结"。若站点分类体系需要与日报保持一致，请把 category 改为 "AI每日总结"，其余字段不变。
只读优先：本文件生成过程未执行任何写入以外的操作，未提交、未删除、未覆盖任何既有文件。

AI每周总结-地球物理（2026-W39）

Sun, 27 Sep 2026 00:00:00 GMT

AI每周总结 · 地球物理（2026-W39：2026-09-21 ~ 2026-09-27）

📌 分类口径（本期起生效）：AI/地球物理 = 以深度学习/机器学习/神经网络/生成模型/强化学习等为核心创新；传统方法 = 以物理/数学/数值/信号处理/反演/成像/层析等为核心，不以 DL/ML 为主要创新（AI 仅作辅助，或 ML 框架仅作计算工具、无学习组件）。

一、本周概览

项	值
覆盖区间	2026-09-21 ~ 2026-09-27（2026-W39）
日报份数	5（09-21、09-22、09-23、09-24、09-25〔v1+v2〕）
主榜单条位	60 条位（09-25 双版本贡献 20 条）
去重后独立条目	约 57 条（3 条为跨期重复命中：SDI、ES-MDA-A2、HFNO）
两类分布（条位）	AI/地球物理 39 / 传统方法 21；传统方法密度在 09-25 v2（期刊侧扫描日）达到峰值（7/10）
⭐ 本周最大事件	连续 8 天的 HPC 缺口在 09-22 终结，且形态从"系统/工作流"演化到"算法并行化"再到"内存/显存工程"——注意：本周 HPC 增量大部分落在传统方法线
⭐ 本周第二条主线	评测口径/可复现性从单条警示升级为当日主线（09-25 SPBench + v2 独立佐证）——AI 线的内部清算
可复现资产	GRADSOLVE（GitHub，MIT，传统/可微）、TorchFDTD（论文，传统/HPC）、SPBench（地址已确证但页面 404，AI）、PINN Atlas / SVGDFWI（延续上周）
开源地震栈	Devito / SPECFEM3D / SeisSol 全周无新 release（本系列连续多期确认）
来源结构翻转	09-25 v2 首次由期刊侧反超：10 条中 8 条来自正式期刊（Geophysics×2、Frontiers in Earth Science×2、Applied Geophysics×3、Earthquake Science×1），原因是 `issn:` 区间扫描命中了 `cat:` 覆盖不到的期刊——期刊侧同时是传统方法条目的主要来源

二、本周主线（跨日归并，8 条；每条标注所涉类别）

主线 1 ·【传统方法·HPC】⭐ HPC 缺口的终结，以及它的三段式演化

这是本周（也是本系列）最重要的结构变化。前 6 天（09-15 ~ 09-21）持续记录"HPC 侧无系统/方法学产出"，09-21 甚至建议把 HPC 源检查降频为每周一次。本周发生了清晰的三段演化：

阶段	日期	代表条目	类别	形态	关键数字
① 系统/工作流	09-22 #1	资源采集式 HPC 工作流（arXiv 2609.22814，已被第八届 Interactive and Urgent HPC 研讨会接收）	传统（HPC 系统，NN 为工作流组件）	算力时间维度复用：平时空闲算力建 NN 训练集，震时切换到"NN 反演 + 物理模拟 + 动态加密"	能耗 −76%、吞吐 3.7×、应急成本 −97.9%、震后 30 分钟出图（⚠️ 全部为摘要自述）
② 算法并行化	09-23 #2	分布式近端 SVGD 走时层析（arXiv 2609.26653）	传统（贝叶斯数值反演；SVGD 无神经网络）	共识型 ADMM + worker 内 SVGD，用 Woodbury 恒等式导出数据空间 GN 更新；声称无需显式构造大规模敏感矩阵	⚠️ "降低 3D 内存占用"为定性表述，无倍数
③ 内存/显存工程	09-24 #1/#4、09-25 #3/#4	MENO、Kokkos FE 核、TorchFDTD、Diff-NekRS、GRADSOLVE、"Beyond Compression"	AI 1 条（MENO）+ 传统 4 条	显存与分辨率解耦 / 性能由装配如何映射到存储层次决定 / 全局状态与 checkpoint 换出主机内存	TorchFDTD：2.7–3.1× 时间换 56%–65% 峰值显存，离散格式不变；稀疏 FFT：2.9–11.6× 显存收益

本周形成的核心判断：大型 3D 地震计算的约束条件是内存，不是 FLOPs。 本周共有 6 条以上独立来源指向同一结论，足以作为内部架构选型的硬约束写入。

第二条判据：融合 CUDA 核与自动微分不兼容被两条独立来源点名——TorchFDTD（光子 FDTD）与 Diff-NekRS（不可压 CFD，Argonne，1020 MPI ranks）都选择手工实现精确离散伴随而非让 AD 穿透核函数，并分别用"与中心差分相差 0.78%"和"端到端 Taylor 检验"验证。Diff-NekRS 的措辞尤其关键：对"完全离散的时间步"求导（discretize-then-optimize）。结论：只要正演有手写 CUDA 核，就别指望 AD，必须准备转置核。

⚠️ 但必须清醒：三个开源地震栈仍无新 release。HPC 增量来自研究方法侧，而非开源工具侧——短期只能靠自己实现论文中的并行架构。

主线 2 ·【AI/地球物理】⭐ 评测口径与可复现性：本周从"某条警示"升级为"当日主线"

09-21 #4 PosteriorBench（arXiv 2609.20794）：用拒绝采样/MCMC 造参考后验，一次给出 5 项分布匹配指标，并开源代码。其自陈结论"当前解法普遍存在显著后验匹配差距"，是对 09-19/09-20 那批扩散先验 FWI 工作最直接的一次压力测试。
09-21 #5：把去噪评价从波形误差延伸到下游任务（检测率、到时拾取、初动极性），并做分布外测试。
09-25 #1 SPBench（arXiv 2609.28925）：审计 368 篇论文发现仅 25 篇公开代码，并给出**"合成排名不能可靠预测实测排名"**的实测结论。
09-25 v2 #2 泄漏感知全剖面评估 + 半监督地震相分割（10.3389/feart.2026.1910345）：用 F3 / Parihaka 两个公开数据集独立证明**"架构差异小于随机种子差异"，并把泄漏来源精确定位到"重叠 patch 的随机切分"**。
09-23 #3 / #6：成本—精度失效边界；全局指标在带外尾部偏移处可能系统性误导。
09-25 #2 独立佐证：Applied Sciences 的 operator-budget 工作指出等优化步数比较会掩盖采样提议的额外残差开销。

行动结论（两条独立来源一致且可执行）：先修评测协议（整剖面切分 + buffer gap + 多种子），再谈架构创新。

主线 3 ·【AI/地球物理】扩散 × FWI：从"后验采样/正则化"推进到"工序级替代"，并拿到实测泛化证据

本系列自 09-15 起跟踪该簇（PSG 后验采样 → SVGDFWI 粒子变分 → GPR 扩散正则化 → 本周 #1 深度渐进 VMB）。本周的位置变化在于：

09-23 #1 Shallow-to-deep VMB via diffusion（Part I + Part II）（arXiv 2609.26454 / 2609.26482）：不再把扩散当正则化或采样器，而是直接替代"速度模型建立"这道工序。Part II 用"迁移派生属性 + 层析背景 + 稀疏井"这套真实可得的条件组合，在实测数据上完成闭环（⚠️ KAUST 为推断，代码/数据/同行评议状态未验证）。
09-25 #2 HFNO（10.1016/j.jappgeo.2026.106528）—— 见"主线 4"。

判断：若 09-23 #1 的结论成立，这是本系列跟踪以来该方向最接近可落地的一次。

主线 4 ·【AI/地球物理】神经算子的"边界"被系统性界定，且首次拿到可量化的正演加速

四条独立证据构成完整的三角：

维度	条目	结论
成本—精度失效边界	09-23 #3（arXiv 2609.24021）	在刻意对神经算子有利的设定下（训练成本完全摊销），仍存在经典求解器胜出的区间
OOD 可审计诊断	09-23 #6（arXiv 2609.23529）	能量范数误差分解为"模型谱近似项"与"输入分布谱加权项"，诊断量无需真值即可计算
价值重定位	09-24 #3（arXiv 2609.24947）	核心论点：神经算子不需要准，只需要把优化放进正确的解盆地；用 Allen-Cahn 展示"残差很小但收敛到错误分支"——与 FWI 的 cycle skipping 是同一命题的两种语言
长时程稳定性 + 梯度一致性	09-25 #5（arXiv 2609.30198）、09-25 v2 KATOsuper	改善长 rollout 稳定性会让常规训练指标变差；预测梯度必须与预测目标场自洽，否则基于梯度的优化不稳定

正面证据：09-24 #2 / 09-25 #2 HFNO（10.1016/j.jappgeo.2026.106528，CNPC + 吉林大学）。09-24 期只拿到 DOI/作者/机构（无摘要），09-25 期通过 OpenAlex 直查取到完整摘要，首次拿到量化结果：

方法：标准 FNO 在谱处理中截断高频模式 → 增设专用高频 Fourier 分支做显式频段选择；另提出时权因果损失把声波传播的因果性嵌入训练目标。
数据：三个地质复杂度递增的基准，最难一档为 SEG-Combined（SEG/EAGE Salt + Overthrust 拼合）。
量化：三数据集上 HER（高频能量比误差）全部最低；相对标准 FNO 基线最多降低 HER 误差 33%；CPU 单次正演 1.34 s、相对同硬件 Devito 有限差分 3× 加速；GPU 0.0094 s/次。
⚠️ 日期口径：OpenAlex publication_date = 2026-09-18；Crossref created = 2026-09-18；Crossref published = 2026-12（卷期归属月）。这是本系列 11 期以来唯一一条同时满足「神经算子 + 三维地震正演 + 中文单位 + 有量化加速比」的条目。

主线 5 ·【AI 为主，1 条传统】贝叶斯/概率反演：机制库扩到第六、七种，并开始"分布式化"

机制累积（AI 线）：扩散后验采样 → INN → HMC → 神经似然 HMC → SVGD → B-BiLo（09-22 #3）。
分布式化（传统线）：共识 ADMM + SVGD（09-23 #2）。
09-22 #3 B-BiLo（10.1038/s41467-026-77768-7）：上层 HMC 采样参数 + 下层 LoRA 近似解算子，显式宣称"无需合成数据、无需伴随方程"，并给出下层近似误差对后验精度的影响分析。⚠️ 但实验只有肿瘤生长等扩散型 PDE，恰恰避开了 PINN Atlas 指出的难点区（双曲型/波动）。
09-24 #6 DispSAC（EarthArXiv 10.31223/x5mj75）：策略集成派——用 RL 策略的多次初始化离散度描述解的变异性。⚠️ 优势是成本，缺口是它不等于后验。本系列立场：可作稳定性扫描，不应作为 UQ 交付物。
09-25 v2 #5 GRADSOLVE（arXiv 2609.28458，代码 github.com/ECLIPSE-AI4Science/gradsolve，MIT，27 stars）：JAX + 线程级 ensemble 并行。可微 HPC 三条路线至此完整成型（均为传统/可微线）：PyTorch + 手写核 + 离散伴随（TorchFDTD）；MPI 千核求解器在环（Diff-NekRS）；JAX + 线程级 ensemble 并行（GRADSOLVE）。共同点：都不是靠通用 AD 直接套在正演上。

主线 6 ·【AI/地球物理】LLM / Agentic 地球物理：从"闭源宣示"走向"有细节可评"，但仍无与传统方法的定量对比

09-17 #1 Agentic FWI（跨周）—— 至今摘要与全文均不可得，跨期 ≥ 3 期悬置。
09-22 #4 VLM 视觉地震学（Research Square rs-10830064）：把波形渲染成无损图像喂给 VLM 做 P/S 到时拾取，提出注视点式（foveated）多阶段缩放与形态学弃权协议，并命名了两个失效模式（compliance bias 顺从偏差、text-scalar decoupling 文本-标量解耦）。⚠️ 预印本未审稿，无与传统拾取器的定量对比。
09-23 #4（10.1029/2026JH001578）：把台站坐标、P 波到时、峰值地速直接喂给 TinyLlama + LoRA 输出震级/位置/发震时刻，显式声明"不需要速度模型"，并与 INGV 业务化自动方法对照——本系列第一条带业务系统对照基线的 LLM 地震学工作。⚠️ 明确报告"加 S 波收益不足以抵消延迟"。
09-25 v2 另有 LLM Agent + XGBoost 液化评估（完整数据流与量化指标）。

判断：Agentic/多模态地球物理 已从"存在性信号"升级为"有细节可评"，但仍无任何一条给出与传统方法的定量对比。值得注意的是 TinyLlama + LoRA 与 09-19 的 XiaoNet（240 KB） 同属"小模型 + 轻量微调"路线——这条线比"接一个大 LLM"更可能先落地到台站侧。

主线 7 ·【传统方法】传统数值方法在本周集中回归

09-25 v2 的十席中有四条是非 AI 的数值方法，且都直接服务 FWI/层析的底座：

条目	类别细分	服务对象
混合地形相关 eikonal 求解器（10.1190/geo-2025-0302）	传统（走时计算）	FWI 初始模型 / 层析
多尺度并行时间步进三维时域电磁模拟（10.1190/geo-2025-0182）	传统（正演并行）	正演并行
双曲 Radon 域分块自适应阈值 FISTA（10.1007/s11770-026-1616-6）	传统（信号处理/去噪）	去噪 baseline
Kalman 后续波至速度-反射界面同时走时反演（10.1007/s11770-026-1547-2）	传统（反演）	初值构建

另加 09-25 v1 #8（GPR FWI 稳定初始模型构建，10.1007/s11770-026-1617-5，传统）。

与主线 1 形成互补：HPC 侧在解决"算得起"，本轮传统方法在解决"算得准、起得来"。

主线 8 ·【AI/地球物理·中文团队】中文团队产出密度高，但集中在应用侧且代码基本不公开

本周参与的中文单位（据日报摘录）：SPBench：北大 + 哈工大；HFNO：CNPC + 吉林大学；PINNForge：南开 + 华东师大；GMD 矿产 UQ：地大武汉；3D-DCTU：浙大海洋学院 + CNPC；DFRSeisNet：成都理工大学 + 东方地球物理 BGP；多尺度逐步学习网络：RIPED + BGP（四川盆地 7 口盲井）；神经核函数：中国地质大学（北京）；Applied Geophysics 系列：成都大学 / 西南交大 / 中南大学；eDWI / IFWI：中国海洋大学（跨周）。

共同特点：数据实测、指标具体、但代码基本不公开。 本周 60 条位中仅 GRADSOLVE（传统/可微）与延伸观察候选 FrFNO 提供了可访问代码链接。

三、本周精选 Top 10（AI/地球物理 6 条 + 传统方法 4 条，整体按相关性排序）

配比说明：本周原 Top 15 经新口径归类后，AI/地球物理 11 条、传统方法 4 条。按"AI 6 + 传统 4"配比重排为 Top 10；移出主榜的 5 条（B-BiLo、basin 选择、VLM、Kokkos、TinyLlama↔INGV）进入提名区并标注类别。降级理由：B-BiLo 实验仅覆盖扩散型 PDE（避开了波动方程难点）；VLM 与 TinyLlama 属地震监测应用侧、且无与传统方法的定量对比；Kokkos 与 TorchFDTD/GRADSOLVE 同属"内存/HPC"证据链，保留代表性最强的两条；basin 选择为观点性论据（Allen-Cahn 演示），已并入主线 4 表述。这 5 条的完整信息仍在提名区与主线中，无信息损失。

1. ⭐ 从空闲到紧急：面向高保真地震估计的资源采集式 HPC 工作流

类别：传统方法（HPC 系统/工作流；NN 反演为工作流组件，核心创新在算力时间复用架构）
作者/团队：机构为二手信源交叉确认（⚠️）
链接：arXiv 2609.22814 · https://arxiv.org/abs/2609.22814 ·〔09-22 #1〕·已被第八届 Interactive and Urgent HPC 研讨会接收
方法：两个专用 kernel + 资源采集（resource harvesting） + 紧急切换机制——把平时空闲算力用于构建 NN 训练集，震时切换为"NN 反演 + 物理模拟 + 动态加密"的应急模式。这是算力时间复用的完整系统架构，不只是加速技巧。
数据/规模：震后高保真成像场景（⚠️ 硬件规模未披露）。
量化：能耗 −76%；吞吐 3.7×；应急成本 −97.9%；震后 30 分钟出图。
代码：未声明（⚠️）。
对本项目的启发：本系列自 09-15 以来第一条"真 HPC"条目，同时命中"面向地震 + HPC 系统层方法学 + 完整量化账"三要件。若项目内有震后快速成像/应急响应场景，这是可直接对标的工作流架构。
验证状态：⚠️ 全部数字为摘要自述；两个 kernel 的设计未展开；30 分钟对应的硬件规模未披露；必须读全文后再引用任何数字。

2. ⭐ SPBench：面向勘探地震处理的多任务评测基准

类别：AI/地球物理（ML 方法评测基准）
作者/团队：北京大学 + 哈尔滨工业大学（据日报摘录）
链接：arXiv 2609.28925（v1，提交 2026-09-24）· https://arxiv.org/abs/2609.28925 ·〔09-25 #1〕
方法/结论：审计 368 篇论文，发现仅 25 篇公开代码；给出**"合成数据上的排名不能可靠预测实测数据上的排名"**的实测结论。
数据：多任务勘探地震处理基准（详见论文）。
可复现性：⚠️ 项目页 404。地址 https://seismicprocessingbenchmark.github.io/SPBench/ 由论文 HTML 全文图注确证（可信），但页面尚未上线；arXiv 摘要页与 HTML 全文均无仓库地址。
对本项目的启发：本周动摇了"在合成数据上刷点即代表方法更好"这一默认前提。与 W41 期的 GeoFWI3D 互补：SPBench 说"评测不规范"，GeoFWI3D 提供"可以用来规范评测的东西"。
验证状态：✅ arXiv 元数据与图注核验；⚠️ 项目页 404，需人工每周复查——这是所有基于 SPBench 的行动建议能否落地的前提。

3. ⭐ 由浅到深的扩散式速度模型建立（Part I 方法 + Part II 真实场景）

类别：AI/地球物理（扩散生成模型；深度渐进生成顺序）
作者/团队：⚠️ KAUST 为单位推断
链接：arXiv 2609.26454 / 2609.26482（提交 2026-09-22）· https://arxiv.org/abs/2609.26454 ／ https://arxiv.org/abs/2609.26482 ·〔09-23 #1〕
方法：深度渐进（depth-progressive）生成式 VMB——显式利用"深部信息依赖浅部"这一地表观测的固有因果结构，把层剥离（layer stripping）思想嵌入扩散模型的生成顺序；直接替代"速度模型建立"这道工序，而非作为正则化或采样器。
数据：Part II 用"迁移派生属性 + 层析背景 + 稀疏井"这套真实可得的条件组合，在实测数据上闭环；自陈"合成数据训练 → 实测泛化，合成响应与实际观测高度吻合"。
代码：未验证（⚠️）。
对本项目的启发：本系列首次拿到"扩散先验在实测 VMB 上不崩"的可引用证据。 若结论成立，这是该方向最接近可落地的一次。建议作为该簇的首选复现目标。
验证状态：⚠️ 机构、DOI、代码、数据集明细、同行评议状态均未验证；性能结论仅为定性自述。

4. ⭐ HFNO：高低频协同傅里叶神经算子用于三维声波场正演

类别：AI/地球物理（神经算子正演代理）
作者/团队：Pengyuan Sun（CNPC）、Puyi Hou（吉林大学）、Ye Lin（吉林大学）
链接：Journal of Applied Geophysics · https://doi.org/10.1016/j.jappgeo.2026.106528 ·〔09-24 #2 → 09-25 #2 升级〕
方法：标准 FNO 在谱处理中截断高频模式 → 增设专用高频 Fourier 分支做显式频段选择以覆盖低频分支丢弃的谱区，形成双路互补；另提出时权因果损失把声波传播的因果性嵌入训练目标。
数据：三个地质复杂度递增的基准，最难一档为 SEG-Combined（SEG/EAGE Salt + Overthrust 拼合）。
量化：HER（高频能量比误差）全部最低；相对标准 FNO 基线最多降低 HER 误差 33%；CPU 单次正演 1.34 s、相对同硬件 Devito 有限差分 3× 加速；GPU 0.0094 s/次。
代码：未声明（⚠️）。
对本项目的启发：本系列 11 期以来唯一同时满足「神经算子 + 三维地震正演 + 中文单位 + 有量化加速比」的条目，可直接作为"神经算子做正演代理"的立项与验收参照。
验证状态：✅ DOI/作者/机构/日期三方交叉（OpenAlex publication_date 2026-09-18；Crossref created 2026-09-18；Crossref published 2026-12 为卷期归属月）；✅ 摘要经 OpenAlex DOI 直查取得；⚠️ 代码未声明。

5. 分布式近端 Stein 变分梯度下降（SVGD）做大规模走时层析贝叶斯推断

类别：传统方法（贝叶斯数值反演 + 分布式并行；SVGD 无神经网络）
作者/团队：⚠️ 机构（德黑兰大学 / Georgia Tech）为推断
链接：arXiv 2609.26653（提交 2026-09-22 16:20:25 UTC）· https://arxiv.org/abs/2609.26653 ·〔09-23 #2〕
方法：把全局走时层析重铸为共识型 ADMM，SVGD 放进 ADMM worker 内部，用 Woodbury 恒等式导出数据空间 Gauss-Newton 更新；明确以"消除大规模敏感矩阵、降低 3D 内存占用"为目标。
数据：大规模走时层析（具体数据集未验证）。
代码：未声明（⚠️）。
对本项目的启发：同时命中 HPC 与贝叶斯两条主线。它与 09-22 #1 合起来第一次勾出"地震反演的 HPC 化"的两个层次：算力时间复用（系统层）与算法并行化（算法层）。
验证状态：⚠️ 机构、代码、数据集、"降低内存占用"的量化倍数全部未验证。

6. TorchFDTD：带离散伴随与主机流式执行的 GPU 加速 FDTD

类别：传统方法（数值/HPC；无学习组件）
作者/团队：arXiv 著录（光子学 FDTD，非地震，迁移需自行验证）
链接：arXiv 2609.30039（提交 2026-09-24 16:07:07 UTC；physics.optics + physics.comp-ph；26 页 13 图）· https://arxiv.org/abs/2609.30039 ·〔09-25 #3〕
方法：把全局状态与 checkpoint 换出到主机内存，用时间换显存；手工实现精确离散伴随而非让 AD 穿透核函数，用"与中心差分相差 0.78%"验证。
量化：2.7–3.1× 时间换 56%–65% 峰值显存下降，且离散化格式不变。
代码：未声明（⚠️）。
对本项目的启发：本周"显存第三条路径"中工程上最可直接抄的一条——不改格式、不改数值方法，纯粹做状态流式化。若项目正受 3D FD 显存限制，这条优先级最高。
验证状态：✅ arXiv 元数据核验；⚠️ 领域为光子学 FDTD。

7. MENO：显存高效神经算子

类别：AI/地球物理（神经算子架构）
作者/团队：⚠️ 机构未验证
链接：arXiv 2609.27739（提交 2026-09-23 11:54:03 UTC）· https://arxiv.org/abs/2609.27739 ·〔09-24 #1〕
方法：主张显存占用与数据分辨率解耦；面向"观测空间 ≠ 模型空间"的跨几何算子学习。
数据：算子学习基准（清单未验证）。
量化：⚠️ 参数 −84.4% / FLOPs −69.2%（自述，机构未验证）；"significantly smaller""best accuracy" 均无第三方复核。
代码：仓库内容未审阅（⚠️）。
对本项目的启发：本周"内存而非 FLOPs"信号的第一条贡献者，且首次出现"分辨率无关显存"这一维度的主张。对"由地面观测推地下模型"这类观测空间 ≠ 模型空间的问题有直接适配性。
验证状态：⚠️ 机构、基准清单、全部性能数字未验证。

8. 泄漏感知的全剖面评估与标签高效半监督地震相分割

类别：AI/地球物理（半监督分割 + 评测方法论）
作者/团队：Frontiers in Earth Science 著录（日报未展开具体名单）
链接：https://doi.org/10.3389/feart.2026.1910345（CC BY 4.0）·〔09-25 v2 #2〕
方法/结论：用 F3 / Parihaka 两个公开数据集证明**"架构差异小于随机种子差异"，并把数据泄漏来源精确定位到"重叠 patch 的随机切分"**。
数据：F3、Parihaka（公开）。
代码：未声明（⚠️）。
对本项目的启发：本周最有分量的方法论信号之一，与 SPBench 独立得出一致且可执行的行动结论：先修评测协议（整剖面切分 + buffer gap + 多种子），再谈架构创新。
验证状态：✅ 期刊/DOI/CC BY 核验；⚠️ 具体数值需读全文。

9. GRADSOLVE：在 GPU 上求解并微分 ODE 集合（可微 HPC 第三条路线）

类别：传统方法（可微 HPC；JAX AD 为计算工具，无学习组件）
作者/团队：⚠️ HTML 抓取仅得 University of London / Oxford 片段，作者机构未确证；领域为天体物理
链接：arXiv 2609.28458 · https://arxiv.org/abs/2609.28458 · 代码 https://github.com/ECLIPSE-AI4Science/gradsolve（MIT，27 stars，创建 2026-09-02，末次推送 2026-09-03） ·〔09-25 v2 #5〕
方法：JAX + 线程级 ensemble 并行，实现大规模 ODE 集合的求解与微分。
数据：天体物理 ODE 集合（迁移需自行验证）。
代码：✅ 仓库链接与许可核验。
对本项目的启发：可微 HPC 三条路线至此完整成型（离散伴随 / 求解器在环 / JAX ensemble），且本周唯一附带真实可访问代码的条目。适合作为"JAX 生态做地震正反演"的技术验证起点。
验证状态：✅ 仓库链接与许可核验；⚠️ 作者机构未确证。

10. 成本—精度权衡：神经算子 vs 经典数值求解器

类别：AI/地球物理（神经算子适用边界的系统性研究）
作者/团队：⚠️ 机构（Caltech）为推断
链接：arXiv 2609.24021（提交 2026-09-21 02:45:25 UTC）· https://arxiv.org/abs/2609.24021 ·〔09-23 #3〕
方法/结论：在刻意对神经算子有利的设定下（训练成本完全摊销），仍存在经典求解器胜出的区间；给出成本—精度帕累托前沿与失效边界。
数据：算子学习基准 suite（具体算例未验证）。
代码：未验证（⚠️）。
对本项目的启发："什么时候不该用神经算子"的答案。 与 PINN Atlas（高频 Helmholtz 差 2–3 个量级）构成同一条"不要盲目替代经典求解器"的证据链，但本条更系统、更可执行。用于做 surrogate 立项排序。
验证状态：⚠️ 机构、代码、具体算例与图表数值未验证。

本周提名区（第 11–25 位，供追踪，不展开；标注类别）

序	条目	类别	来源	首次收录
11	B-BiLo：带低秩适配的贝叶斯双层算子学习（免伴随路线；⚠️ 实验仅扩散型 PDE）	AI	10.1038/s41467-026-77768-7	09-22 #3
12	Learning Physics from an Imperfect Ancestor（surrogate 的价值在 basin 选择而非精度；与 FWI cycle skipping 同构）	AI	arXiv 2609.24947	09-24 #3
13	多模态大模型视觉地震学（VLM 做 P/S 拾取；命名两个失效模式；无与传统拾取器定量对比）	AI	10.21203/rs.3.rs-10830064/v1	09-22 #4
14	基于 Kokkos 的低阶 GPU 加速有限元核函数性能分析（性能由访存映射决定，而非算术强度）	传统（HPC）	arXiv 2609.21681	09-24 #4
15	适配预训练 LLM 快速反演震级与位置（TinyLlama+LoRA，与 INGV 业务系统对照）	AI	10.1029/2026JH001578	09-23 #4
16	方向感知掩码预训练 3D 地震表征学习 → 跨工区波阻抗反演（实证"重建保真度 ≠ 可迁移性"）	AI	arXiv 2609.24615	09-23 #5
17	PosteriorBench：生成式反演器的后验匹配评测（参考后验 + 5 项指标 + 开源代码）	AI	arXiv 2609.20794	09-21 #4
18	地震波形去噪跨时间域/时频域/混合域系统评测（以下游任务为指标）	AI	10.1029/2026JH001403	09-21 #5
19	ActSeisDAS：连续主动源 DAS 监测的边侧 Python 框架（99.9% 数据缩减，324 GB/天 → 16 MB，24 小时数据 46 分钟）	AI	10.1016/j.acags.2026.100410	09-21 #9
20	CASCU：混合注意力网络做自适应地震绕射波分离	AI	10.3389/feart.2026.1898241	09-25 v2 #1
21	Diff-NekRS：多时间步"求解器在环"训练的可微框架（Argonne，1020 MPI ranks）	传统（可微 HPC）	arXiv 2609.23208	09-25 #4
22	Beyond Compression：神经代理求解器长时程 rollout 的潜表示训练（FLOPs −2 个量级、显存减半）	AI	arXiv 2609.30198	09-25 #5
23	任意发射波形三维时域电磁多尺度并行时间步进	传统	10.1190/geo-2025-0182	09-25 v2 #6
24	RSDB：Raspberry Shake 全球地震波形数据集（面向 ML）	AI（数据集）	10.1016/j.eqs.2026.06.001	09-25 v2 #10
25	3D-DCTU（真 3D 网络，SEG Geophysics）vs DFRSeisNet（分块 + 全局-局部分解，Sensors）——同一问题的两种相反处方	AI	10.1190/geo-2024-0855 ／ 10.3390/s26185938	09-24 #5 / #8

四、本周全量条目索引（60 条位，按日报原序；含类别列）

类别标注为本文件按"分类口径"对日报内容的重新归类，不改变日报原文。"（AI 辅助）"= AI 仅作辅助环节；"（可微）"= ML 框架仅作求导工具、无学习组件。

2026-09-21（窗口 09-14 ~ 09-21）

#	条目	类别	链接
1	Structure-Driven Inversion（SDI）⚠️ 跨期重复（首收 09-16 #1）	传统（范式）	https://arxiv.org/abs/2609.16536
2	Physics-guided FCN using attenuation information for viscoacoustic VMB	AI	https://doi.org/10.21203/rs.3.rs-10933226/v1
3	Efficient matrix-free Gauss-Newton traveltime tomography on full-metric deformed grids	传统	https://arxiv.org/abs/2609.14982
4	PosteriorBench: From Point Estimates to Posterior Matching	AI	https://arxiv.org/abs/2609.20794
5	Earthquake Seismogram Denoising Across Time, Time-Frequency, and Hybrid Domains	AI	https://doi.org/10.1029/2026JH001403
6	DAS-SPP: Transformer-based seismic phase picking on DAS data	AI	https://doi.org/10.1016/j.cageo.2026.106264
7	Linearized PINN with pretrained nonlinear layers	AI	https://arxiv.org/abs/2609.14926
8	Physics-Guided Conditional Flow Matching with Energy Regularization	AI	https://arxiv.org/abs/2609.15536
9	ActSeisDAS: Python-based edge framework for continuous active seismic DAS monitoring	AI	https://doi.org/10.1016/j.acags.2026.100410
10	Adaptive and accuracy-aware multiple data assimilation（ES-MDA-A2）⚠️ 跨期重复（首收 09-16 #6）	传统	https://arxiv.org/abs/2609.16434

2026-09-22（窗口 09-15 ~ 09-22；arxiv geo-ph 主窗口仅 16 条）

#	条目	类别	链接
1	⭐ From Idle to Urgent: A Resource-Harvested HPC Workflow for High-Fidelity Seismic Estimation	传统（HPC 系统）	https://arxiv.org/abs/2609.22814
2	Inversion of Elastic Properties of Stratified Layered Media using EDWI	传统	https://doi.org/10.1190/geo-2025-0147
3	Bayesian bilevel operator learning with low-rank adaptation（B-BiLo）	AI	https://doi.org/10.1038/s41467-026-77768-7
4	Do AI dream of P and S picks? Multimodal LLMs applied to visual seismological analysis	AI	https://doi.org/10.21203/rs.3.rs-10830064/v1
5	Reinforcement Learning-based Task Aware Denoising for DAS Seismic Data（RL-TAD）	AI	https://doi.org/10.1190/geo-2024-0704
6	Can Deep Learning Achieve Cross-Physics Mapping?（CPM）	AI	https://arxiv.org/abs/2609.16853
7	HiLNO: Hierarchical Latent Neural Operator with Multi-Scale Supervision	AI	https://arxiv.org/abs/2609.18419
8	AI-Driven Scientific Computing Workflows: A Systems Review	AI（综述）	https://arxiv.org/abs/2609.21162
9	FaultNet: Inferring Complex Fault Structures from Earthquake Hypocenter Distributions	AI	https://doi.org/10.5281/zenodo.22837108
10	PDEs in the age of machine learning: a critical synthesis	AI（综述）	https://doi.org/10.1007/s10462-026-11677-5

2026-09-23（窗口 09-16 ~ 09-23）

#	条目	类别	链接
1	⭐ Shallow-to-deep velocity model building via diffusion models — Part I / Part II	AI	https://arxiv.org/abs/2609.26454 ／ https://arxiv.org/abs/2609.26482
2	Distributed Proximal SVGD for Large-scale Bayesian Inference in Traveltime Tomography	传统	https://arxiv.org/abs/2609.26653
3	Cost-Accuracy Trade-offs: Neural Operator vs Classical Numerical Solver	AI	https://arxiv.org/abs/2609.24021
4	Adapting a Pretrained LLM to Rapidly Recover Earthquake Magnitude and Location	AI	https://doi.org/10.1029/2026JH001578
5	Direction-Aware Masked Pretraining for 3D Seismic Representation Learning	AI	https://arxiv.org/abs/2609.24615
6	Predicting OOD Generalization of Neural Operators via Spectral Error Decomposition	AI	https://arxiv.org/abs/2609.23529
7	Multiscale Stepwise Learning Network for Seismic Impedance Inversion	AI	https://doi.org/10.3390/app16189358
8	Spatio-Temporal Neural Kernel Function Model for Earthquake Clustering（ETAS ↔ 神经点过程）	AI	https://doi.org/10.1029/2025JH001110
9	Detection of the 2019 Hikurangi slow event using a transformer DL model	AI	https://doi.org/10.13168/agg.2026.0027
10	StrainProx: Seismic Time-Strain Inversion with Proximal Solvers	传统	https://doi.org/10.1190/tle-2026-1107

2026-09-24（窗口 09-17 ~ 09-24）

#	条目	类别	链接
1	MENO: Memory-Efficient Neural Operator	AI	https://arxiv.org/abs/2609.27739
2	⭐ High-low frequency collaborative FNO for 3D acoustic seismic wavefield modeling（HFNO）	AI	https://doi.org/10.1016/j.jappgeo.2026.106528
3	Learning Physics from an Imperfect Ancestor	AI	https://arxiv.org/abs/2609.24947
4	Performance Analysis of Low-Order, GPU-accelerated FE Kernels using Kokkos	传统（HPC）	https://arxiv.org/abs/2609.21681
5	A hybrid CNN-Transformer network for linear noise suppression in 3D seismic data（3D-DCTU）	AI	https://doi.org/10.1190/geo-2024-0855
6	DispSAC: Surface-wave dispersion inversion using soft actor-critic RL	AI	https://doi.org/10.31223/x5mj75
7	GenVoid: Uncertainty-Aware Learning of Subsurface Material Defects	AI	https://arxiv.org/abs/2609.23761
8	DFRSeisNet: Fluctuation-Prior-Regularized Background Noise Attenuation	AI	https://doi.org/10.3390/s26185938
9	Beyond PINNs: Unified Gauss-Newton and Petrov-Galerkin Framework	传统（数值）	https://arxiv.org/abs/2609.20641
10	Mechanism-oriented tendency-integration operator networks for PDE foundation models	AI	https://doi.org/10.21203/rs.3.rs-10822726/v1

2026-09-25 v1（窗口 09-18 ~ 09-25）

#	条目	类别	链接
1	⭐ SPBench: A Multi-Task Evaluation Benchmark for Exploration Seismic Processing	AI	https://arxiv.org/abs/2609.28925
2	HFNO 三维声波场正演 ⚠️ 跨期重复 + 升级（首收 09-24 #2，本期取得完整摘要）	AI	https://doi.org/10.1016/j.jappgeo.2026.106528
3	TorchFDTD: GPU-accelerated FDTD with discrete adjoints and host-streamed execution	传统	https://arxiv.org/abs/2609.30039
4	Diff-NekRS: Scalable Differentiable Framework for Multi-Timestep Solver-in-the-Loop Training	传统（可微）	https://arxiv.org/abs/2609.23208
5	Beyond Compression: Latent Representations for Stable Long-Horizon Rollout in Neural Surrogate Solvers	AI	https://arxiv.org/abs/2609.30198
6	Conformal Structure of the Brinkman Penalisation Method for Operator Learning of Hamiltonian PDEs	AI	https://arxiv.org/abs/2609.29847
7	Learning Operators of Geometry with an Interface Autoencoder	AI	https://arxiv.org/abs/2609.29437
8	Stable Initial Model Construction for 2D Single-Parameter GPR FWI	传统	https://doi.org/10.1007/s11770-026-1617-5
9	Automated Workflow for Focal Mechanism Determination of Low-Magnitude Earthquakes（SE Alps）	传统（自动化流程）	https://doi.org/10.1785/0220260124
10	Parameter estimation for land-surface models using Neural Physics	传统（可微，免伴随；前向完全基于物理、不做任何训练）	https://doi.org/10.5194/gmd-19-8801-2026

2026-09-25 v2（第二轮检索增补，15:05）

#	条目	类别	链接
1	Adaptive seismic diffraction separation via hybrid attention-based CASCU network	AI	https://doi.org/10.3389/feart.2026.1898241
2	⭐ Leakage-aware full-section evaluation and label-efficient semi-supervised seismic facies segmentation	AI	https://doi.org/10.3389/feart.2026.1910345
3	Hybrid topography-dependent eikonal solver for acoustic tilted orthorhombic anisotropy	传统	https://doi.org/10.1190/geo-2025-0302
4	Stratigraphy-guided joint inversion of acoustic impedance and resistivity（碳酸盐岩储层）	传统	https://doi.org/10.3389/feart.2026.1900017
5	⭐ GRADSOLVE: Differentiable astrophysics at scale（代码 github.com/ECLIPSE-AI4Science/gradsolve，MIT）	传统（可微）	https://arxiv.org/abs/2609.28458
6	Multiscale parallel time-stepping for 3D time-domain electromagnetic data	传统	https://doi.org/10.1190/geo-2025-0182
7	Gravity Inversion Based on Vision Transformer（鄱阳湖盆地）	AI	https://doi.org/10.1007/s11770-026-1608-6
8	Block adaptive thresholding FISTA for random noise suppression in hyperbolic Radon domain	传统	https://doi.org/10.1007/s11770-026-1616-6
9	Kalman-Based Simultaneous Traveltime Inversion for Velocity and Reflector Geometry	传统	https://doi.org/10.1007/s11770-026-1547-2
10	RSDB — A global seismic waveform dataset from the Raspberry Shake network	AI（数据集）	https://doi.org/10.1016/j.eqs.2026.06.001

五、本周演化：重复 / 升级 / 新增方向（分两线）

5.A AI/地球物理线

周内重复（主榜内的跨期重复命中）

条目	首次收录	本期状态
HFNO（10.1016/j.jappgeo.2026.106528）	09-24 #2	09-25 #2 再入榜，并取得完整摘要与量化结果（见 5.A 升级表）

升级（前日"信号"→ 拿到可核验证据）

升级项	轨迹	结果
⭐ HFNO 三维声波场正演	09-23 期"按标题检索无命中、字段全缺"→ 09-24 期经 OpenAlex + Crossref DOI 反查拿到 DOI/作者/机构（仍无摘要）→ 09-25 期经 OpenAlex DOI 直查取得完整摘要	✅ 拿到方法 + 数据 + 量化加速比（HER 最多降 33%；CPU 1.34 s、相对 Devito 3×；GPU 0.0094 s/次）
XiaoNet	09-19 摘要未获取 → 09-22 经 OpenAlex 取到完整摘要（>93% 压缩 / 240 KB / 亚毫秒）	✅ 数字可用；⚠️ 同时暴露 OpenAlex 机构映射错误
神经算子清算线	09-21 #4 PosteriorBench（后验对不对）→ 09-22 #10 PINN Atlas（高频 Helmholtz 差 2–3 量级）→ 09-23 #3 成本—精度边界、#6 OOD 谱诊断	✅ 形成 3 条独立、可引用的支撑
Agentic/多模态地球物理	09-17 #1 Agentic FWI（摘要不可得）→ 09-22 #4 VLM 地震学（命名失效模式）→ 09-23 #4 TinyLlama ↔ INGV 业务对照	✅ 从"存在性信号"升级为"有细节可评"；❌ 仍无与传统方法的定量对比
PINN 定位	09-20 PINN Atlas 量化清算 → 09-21 #7 lPINN 给出对应工程解法（离线学基、在线只解最后一层，在线推理快 1–3 个数量级）	✅ 批评与补救在同一周期配对

本周新增方向

🆕 视觉语言模型（VLM）做地震学判读（注视点式多阶段缩放 + 形态学弃权协议 + 两个被命名的失效模式）
🆕 跨物理域映射（Cross-Physics Mapping）：同一潜流形上学习扩散场 ↔ 波场双向算子，并量化出方向不对称性
🆕 强化学习做"逐区域去噪策略选择"（A3C 智能体按数据区域挑选轻量去噪网络）
🆕 双层算子学习 + LoRA 的免伴随贝叶斯反演（权重空间采样 → 参数空间采样）
🆕 深度渐进（depth-progressive）生成式 VMB（层剥离思想嵌入扩散生成顺序）
🆕 神经算子的成本—精度帕累托前沿与失效边界
🆕 神经算子的可审计 OOD 诊断（无需真值；误差谱分解）
🆕 方向感知的三维地震自监督预训练（"重建保真度 ≠ 可迁移性"反例）
🆕 神经核函数替代 ETAS 经验核（保留 Hawkes 点过程概率结构）
🆕 "神经算子的价值在 basin 选择而非精度"
🆕 分辨率无关的神经算子显存 / 跨几何（cross-geometry）算子学习
🆕 反问题的"可观测性度量"（面向采集设计）
🆕 PDE 基础模型的"机制可干预性"
🆕 地震处理领域系统性"可复现性证据"（368 篇审计；合成排名 ≠ 实测排名）
🆕 潜空间代理"长时程稳定性"是训练目标问题而非结构问题（反直觉：改善 rollout 稳定性会让常规指标变差）

5.B 传统方法线

周内重复

条目	首次收录	本期状态
ES-MDA-A2（2609.16434）	09-16 #6（W38）	09-21 再次排入 #10，无更新
SDI（2609.16536）	09-16 #1（W38）	09-21 再次排入 #1，但无新版本、无代码、无实验

升级

升级项	轨迹	结果
⭐ HPC 缺口终结	09-17~09-21 连续 5 期记录"HPC 无系统/方法学产出"→ 09-22 #1 一次性补齐"面向地震 + 系统层方法学 + 完整量化账"三要件	✅ 缺口终结的是"方法学供给"，不是"工具链更新"
矩阵自由 GN	09-19 #5 CSEM（W38）→ 09-21 #3 全度量形变网格上的初至走时层析（图凝聚 + 块三角分解复用 Krylov 输运算子）	✅ 从单一应用扩展到走时层析
可微 HPC 路线图成型	09-25 #3 TorchFDTD（离散伴随）+ #4 Diff-NekRS（求解器在环）+ v2 #5 GRADSOLVE（JAX ensemble，本周唯一可访问代码）	✅ 三条路线全部为传统/可微线，共同点"不靠通用 AD 直接套正演"

本周新增方向

🆕 Urgent Interactive HPC / 资源采集（完整的算力时间复用架构）
🆕 共识 ADMM + 粒子变分推断的分布式贝叶斯反演（去中心化子问题 + worker 内 SVGD）
🆕 "融合 CUDA 核 + AD 不兼容"被点名，离散伴随成为显式替代（两条独立来源，均给出精度与规模实测）
🆕 免伴随（adjoint-free）可微反演（Neural Physics：ML 框架 AD 替掉伴随推导，前向模型完全基于物理、不做任何训练）
🆕 传统数值方法集中回归：混合地形 eikonal 各向异性求解器、任意波形三维时域电磁多尺度并行、双曲 Radon-FISTA 分块阈值、Kalman 走时-反射界面同时反演、GPR FWI 稳定初始模型
🆕 变几何算子学习获得理论误差界（Hausdorff / graph-Hausdorff、拓扑证书）

5.C ⚠️ 本周暴露的两类口径问题（务必记住）

日期口径（对 Elsevier 系期刊）：HFNO 的 Crossref published 记为 2026-12（卷期归属月），而 created 与 OpenAlex publication_date 均为 2026-09-18。只用 published 会把窗口内的新上线论文误判为窗口外。 本周起改为「created 与 OpenAlex publication_date 交叉、以较早的实际上线口径为准，并在正文显式列出两个日期」。
机构映射错误（OpenAlex）：XiaoNet 的三位作者单位被 OpenAlex 全部映射为 "Oklahoma Biological Survey"，与论文内容明显不符。结论：机构字段必须双源交叉，不能单信 OpenAlex。

六、本周趋势总结（分两线）

6.A AI/地球物理线

⭐ "可复现性 / 比较口径"第一次成为当日主线，且带着量化证据。SPBench（368 篇仅 25 篇有代码、合成排名 ≠ 实测排名）+ v2 独立佐证（架构差异 < 随机种子差异，泄漏源自重叠 patch 随机切分）。这质疑的是"我们凭什么认为 A 比 B 好"这一前提。
⭐ "扩散 × FWI"从后验采样推进到工序级替代，并首次给出实测泛化证据（09-23 #1 Part II）。
神经算子的边界被三条独立证据界定，并新增"basin 选择"这第二验收口径。用单点误差验收 surrogate 是系统性错误的，应改为「多步 rollout 误差」+「梯度一致性检验」。
"成本叙事"从零散证据变成结构化的三条路径：算力时间维度复用（闲时建训练集 → 震时推理，AI 与 HPC 系统的混合）、模型容量维度压缩（MENO 参数 −84.4% / FLOPs −69.2%；XiaoNet 240 KB）、结构维度降维（LoRA 把权重空间采样降为参数空间采样）。
"让 SciML 可审计"已成独立脉络：PosteriorBench、跨物理域映射的方向不对称、无需真值的 OOD 谱诊断、机制干预实验。四条的共同点是都在问"模型为什么给出这个答案"。
LLM 在地震学中的角色进一步分化（渲染成图再判读 vs 直接吃数值做反演），且开始出现业务系统对照；极小配置（TinyLlama + LoRA / XiaoNet 240 KB）比"接一个大 LLM"更可能先落地到台站侧。
出现一类需要警惕的"廉价 UQ"（RL 策略集成 DispSAC）：它不等于后验，可作稳定性扫描、不应作为 UQ 交付物。
诚实报告密度维持在较好水平：09-23 #4 明确报告"加 S 波收益不足以抵消延迟"；#3 的核心结论之一是神经算子在有利设定下仍会输。

6.B 传统方法线

⭐ HPC 议题从"缺信息"变成"有方法学"，再收敛到"内存/显存"。三阶段：系统/工作流（09-22）→ 算法并行化（09-23）→ 内存工程（09-24、09-25）。核心判断：大型 3D 地震计算的约束条件是内存，不是 FLOPs。（注意：这一判断的证据链大部分来自传统方法线——TorchFDTD、Kokkos、Diff-NekRS、GRADSOLVE、分布式 SVGD。）
"手写 CUDA 核 → 必须准备转置核（离散伴随）"成为明确工程守则；discretize-then-optimize 是措辞层面的关键。
可微 HPC 三条路线成型，且全部不依赖通用 AD：对本项目的含义是——若正演已有手写核，转置核的工程投入应列入计划，而非指望框架自动求导。
免伴随可微反演形成第二条路径（Neural Physics，前向完全基于物理、不做任何训练），与矩阵自由 GN 的数学路径互补。对"已有成熟正演代码但伴随维护成本高"的场景是低风险选项。
传统数值方法集中回归（eikonal、多尺度并行时间步进、Radon-FISTA、Kalman 走时反演），且都服务 FWI/层析的底座——与 HPC 主线形成"算得起 / 算得准、起得来"的互补。
⭐ 期刊侧是本周被低估的富矿，且是传统方法的主要来源：09-25 v2 十席中 8 条来自正式期刊，其中传统方法 7 条（含 4 条纯数值方法）。issn: 日期区间扫描在 Applied Geophysics（1672-7975）上一次就捞出 10 篇，而 cat: 检索完全覆盖不到。→ ISSN 区间扫描应放在 arXiv cat: 检索之前执行。

6.C 综合判断

本周两线产出比约 39:21（AI:传统），传统方法占比为三周最高，主要由两个因素驱动：HPC 缺口终结的增量大部分落在传统方法线（系统/工作流、算法并行化、内存工程），以及期刊侧扫描捞出的传统数值方法集中回归。AI 线在自我清算（评测口径），传统线在补底座（算得起 + 算得准）——两条线本周给出的是同一个信息的两面：领域正在从"提出方法"转向"把方法做实"。

七、对项目的行动建议（本周合并版）

课题口径仍为默认的 AI + HPC + 地震数据处理 + FWI。以下均为建议，未执行任何操作。括号内为所属线别。

A. 立即可做（低风险、低成本，1–3 天）

⭐ 修评测协议——依据 SPBench + 泄漏感知全剖面评估（均为 AI 线）。具体动作：整剖面切分（禁止重叠 patch 随机切分）+ buffer gap + 多种子重复，并在报告里同时给出随机种子间的方差。这是本周投入产出比最高的一条。
把"多步 rollout 误差 + 梯度一致性检验"写入 surrogate 验收清单——依据 09-25 #4/#5 + 09-24 #3（AI 线）。停止用单点误差验收 surrogate。
在内部评测规范中新增"可审计性"一节——依据 09-21 #4、09-23 #6、09-24 #10（AI 线）。
跑通 GRADSOLVE 环境（GitHub，MIT）——本周唯一带可访问代码的可微 HPC 条目（传统/可微线），适合作为 JAX 生态做地震正反演的技术起点。
按"内存优先"重估现有 3D 流程——依据 09-23 #2、09-24 #1/#4、09-25 #3/#5 的六条独立来源（跨两线）。

B. 需要评估（有收益但需先做可行性判断，1–4 周）

评估 TorchFDTD 式"状态换出主机内存"能否移植到现有 3D FD 正演——2.7–3.1× 时间换 56%–65% 峰值显存，且离散格式不变（传统/HPC 线）。这是本周最"可抄"的显存方案。
复现 HFNO（AI 线）——本系列唯一同时满足"神经算子 + 3D 地震正演 + 中文单位 + 量化加速比"的条目。验收口径建议直接用 HER + 与 Devito 同硬件对比。
评估"手写 CUDA 核 → 必须准备转置核"对现有代码库的影响——依据 09-25 #3、#4 的两条独立来源，以及 discretize-then-optimize 这一措辞（传统/HPC 线）。
评估把 basin 选择作为 surrogate 第二验收口径（AI 线），用 FWI cycle skipping 场景做对照实验。
评估 B-BiLo 的免伴随路线在波动方程上是否成立——关键判据：它只在扩散型 PDE 上验证过（AI 线）。
评估 SPBench 项目页是否上线——每周复查一次（截至 09-25 仍 404）。这是所有基于 SPBench 的行动建议能否落地的前提。

C. 仅记录（暂不投入）

SDI / PSDWII 类"零实验零代码"的范式宣示（传统线）——09-21 再次排 #1 但无新证据，维持季度级跟踪。
Agentic FWI（10.1007/s11004-026-10342-5）（AI 线）——跨期 ≥3 期摘要不可得，建议人工判断是否继续投入检索预算。
DispSAC 类"廉价 UQ"（AI 线）——可作稳定性扫描，不应作为 UQ 交付物。
RSDB / Applied Geophysics 摘要缺口——见第八节，建议合并为一次批量人工动作。

D. HPC 侧的具体提醒

开源栈下周复查项（本周实测均无新版本）：Devito v4.8.23 / 2026-08-07；SPECFEM3D v4.1.1 / 2024-03-15；SeisSol v1.3.2 / 2025-06-17。连续多期成立，可考虑把复查频率降为双周。
补订稳定 HPC 信息源：SC / ISC / IPDPS / PPoPP、NVIDIA GTC、SEG/EAGE 年会技术程序、SPECFEM / Devito / SeisSol release notes。
注意"内存而非 FLOPs"应作为硬约束，而非事后优化项。
检索顺序调整：ISSN 区间扫描应优先于 arXiv cat: 检索（本周 09-25 v2 首次实证；且期刊侧是传统方法条目的主要来源）。

八、未解决项 / 需人工确认

8.1 结构性问题（本周持续）

⚠️ 模板变量连续第 6–8 期未注入：{{date}} / {{lookback_days}} / {{history_dir}} / {{lookback_reports}} / {{project}} 全部为原始占位符。建议修改自动化配置注入实际值。
project 未指定：所有"对项目的启发"均按默认课题语境撰写。
对比基线：lookback_reports = 5（09-18 ~ 09-22 五份），逐步成型。

8.2 代码/数据可用性（本周统计）

本周 60 条位中，明确给出可访问代码链接的仅 1 条：GRADSOLVE（GitHub，MIT，传统/可微线）。另有延伸观察候选 FrFNO。
09-25 #1 SPBench 自述将发布数据/实现/配置/评测脚本，但 arXiv 摘要页与 HTML 全文均无仓库地址，GitHub 检索无同名命中；项目页 404。
⚠️ FaultNet（Zenodo 22837108）代码许可未添加（存档说明明确要求发布前补许可）——商用/再发布前必须确认许可。

8.3 跨期悬置项（截至 2026-09-25）

项	悬置	建议动作
SPBench 项目页 404（`https://seismicprocessingbenchmark.github.io/SPBench/`）	09-25 起	每周复查；地址由论文图注确证，页面未上线
Agentic FWI 摘要（10.1007/s11004-026-10342-5）	≥ 3 期	全文闭源，建议人工判断是否继续投入检索预算
Science China Earth Sciences 生成式 AI 综述摘要（10.1007/s11430-025-2038-7）	≥ 3 期（09-18 起）	09-21 已拿到作者/单位/出版日；仅摘要缺失 → 人工浏览器打开一次并回填
伴随法小震矩释放率摘要（Research Square rs-3.rs-10679490/v1）	≥ 3 期（09-21 起）	人工取全文
BicycleGAN 日期冲突（10.1016/j.cageo.2026.106272，Crossref 记 2027-01 vs OpenAlex 记 2026-09-17）	≥ 2 期	人工确认真实上线日期
10.1007/s11770-026-1617-5（GPR FWI 初始模型，传统线）	09-25 起	摘要/方法/数据/代码全部缺失；方向高度相关，值得人工取 PDF
10.1007/s11770-026-1587-7（U-Net 三维重力反演，中南大学/东华理工/自然资源部）	连续三期无摘要	⚠️ 09-25 v2 已建议停止跟踪
GRADSOLVE 作者机构未确证	09-25 起	HTML 抓取仅得 University of London / Oxford 片段
RSDB（10.1016/j.eqs.2026.06.001）	09-25 起	机构/摘要/数据集地址全缺；日期口径冲突（published [2026,10] vs created 2026-09-23）
*4 篇 Springer Applied Geophysics* 条目无摘要**（…1617-5 / …1608-6 / …1616-6 / …1547-2，均为传统线）	持续	Springer 不提供结构化摘要，API 路径已走到尽头 → 合并为一次批量取 PDF 动作
10.1190/geo-2025-0182 日期冲突	09-25 起	Crossref published 2026-09-20 vs created/OpenAlex 2026-09-02
OUP（academic.oup.com）Cloudflare 拦截	09-20 起	GJI 多条代码/数据声明只能人工浏览器打开
Princeton RSE WebGPU/WGSL 求解器	跨周（W38 已 6 次未验证）	建议结案或直接放弃
J. Seismic Exploration 元数据错配	跨周（持续复核仍存在）	该刊 Crossref 著录不可靠，自动筛选必须交叉验证出版商页面

8.4 需人工确认的性能数字（本周）

本周给出可直接引用量化数字的条目显著多于上周（HFNO 的 HER/33%/1.34 s/3×/0.0094 s；Urgent HPC 的 −76%/3.7×/−97.9%/30 分钟；TorchFDTD 的 2.7–3.1×/56%–65%；ActSeisDAS 的 99.9%/46 分钟；MENO 的 −84.4%/−69.2%），但其中多数为作者自述、未独立验证。已逐条在日报标注，选型决策请以自复现为准。

九、检索说明与本文件生成方式

本文件不是检索产物。生成过程为：读取 AI每日总结_2026-09-21.md ~ AI每日总结_2026-09-25.md 五份原文（09-25 含 v1 与第七节 v2 增补）→ 按 ISO 周归并 → 抽取各期"〇对比""趋势总结""未解决项" → 合并同一条目的升级轨迹 → 按"AI/地球物理 + 传统方法"两分类重新归类并标注 → 按 AI 6 + 传统 4 配比重排 Top 10 → 输出本文件。未访问任何外部数据源。
两类条数分布：60 条位中 AI/地球物理 39 条 / 传统方法 21 条（每日分布：09-21 为 7:3、09-22 为 8:2、09-23 为 8:2、09-24 为 8:2、09-25 v1 为 5:5、09-25 v2 为 3:7）。精选 Top 10 配比 6:4；传统方法条数充足（21 条 ≥ 4），无需"凑数"。值得注意的结构性事实：传统方法条目几乎全部来自期刊侧（尤其 09-25 v2 的 ISSN 扫描），而 AI 条目以 arXiv 为主——两类信息的检索渠道本身就在分化。
历史重复/升级/新增：周内重复 3 条（SDI〔传统〕、ES-MDA-A2〔传统〕、HFNO〔AI〕）；升级项分两线列于第五节；新增方向 AI 线 15 项 + 传统线 6 项。与前周（W38）对比的新增方向以 🆕 标注。
分类判定说明（边界条目归类原则）：① 资源采集式 HPC 工作流（NN 为组件、核心创新为系统架构）→ 传统（HPC 系统）；② SVGD/ADMM 走时层析（无神经网络）→ 传统；③ TorchFDTD / Diff-NekRS / GRADSOLVE / Neural Physics（无学习或学习非主体）→ 传统（可微/HPC）；④ Beyond PINNs（Gauss-Newton/Petrov-Galerkin 数值框架）→ 传统（数值）。归类为整理动作，若与原文自述不符，以原文为准。
⚠️ 2026-10-08 变更：按用户要求，本周期 5 份日报已随全部 12 份历史日报移出主目录，现留存于工作区 .回收站_日报_2026-10-08/ 与外部备份 /home/liguolong/geo_scratch/backup_日报_2026-10-08/（删除前校验一致）。09-25 的 v1 与 v2 在周报中合并为"同一日的两轮检索"；日报原文（两段独立内容）请在上述两处查阅。
诚实性声明：
- 所有链接、作者、机构、日期、数字均转述自日报原文；日报未验证的一律沿用"未验证/需人工确认"标注，本文件未做任何新推断或补齐。
- 日报中标为"推断""自述""预印本""二手来源"的内容，在本文件中保持原标注。
front matter 说明：周报使用 tags / category 均为 "AI每周总结"。若站点分类体系需要与日报保持一致，请把 category 改为 "AI每日总结"，其余字段不变。
只读优先：本文件生成过程未执行任何写入以外的操作，未提交、未删除、未覆盖任何既有文件。

AI每周总结-地球物理（2026-W38）

Sun, 20 Sep 2026 00:00:00 GMT

AI每周总结 · 地球物理（2026-W38：2026-09-14 ~ 2026-09-20）

📌 分类口径：

AI/地球物理 = 以深度学习、机器学习、神经网络、基础模型、生成模型、强化学习等为核心创新；

传统方法 = 以物理/数学/数值/信号处理/反演/成像/层析/地震干涉/走时/振幅等为核心，不以 DL/ML 为主要创新（AI 仅作辅助、对比或后处理，或 ML 框架仅作计算工具）。

一、本周概览

项	值
覆盖区间	2026-09-14 ~ 2026-09-20（2026-W38）
日报份数	6（09-15 ~ 09-20）
主榜单条位	60 条位
去重后独立条目	约 41 条（其余为跨日重复命中）
两类分布（条位）	AI/地球物理 44 / 传统方法 16；每日波动大（09-16、09-18 各达传统 5 条，09-15、09-20 仅 1 条）
来源结构（逐期波动）	09-15~09-18 以 arXiv 预印本为主；09-19、09-20 反转为正式期刊为主（8/10）
可复现资产	本周首次拿到可下载代码/数据：DiffSWE2d（GitHub）、SVGDFWI（Zenodo 代码包）、GPR 扩散正则化 FWI 数据（Zenodo，CC BY 4.0）、PINN Atlas（Zenodo + MIT 代码）
HPC 状态	⚠️ 连续 6 天无系统/方法学产出；第 5 天（09-19）起拿到内存侧量化，第 6 天（09-20）拿到跨平台 GPU 实测基线
开源地震栈	Devito v4.8.23（2026-08-07）、SPECFEM3D v4.1.1（2024-03-15）、SeisSol v1.3.2（2025-06-17）——全周无新 release
对比基线	本周为周报系列起点，无前序周报可比；但内部按日报做了逐日"重复/升级/新增"归并

二、本周主线（跨日归并，7 条；每条标注所涉类别）

主线 1 ·【AI/地球物理】生成式先验 × FWI：从"替代正演-伴随链"转向"与 FWI 协作"

本周该方向的四篇工作没有一个追求端到端替换，共同技术关键词是解耦：

09-15 #1 PSG（arXiv 2609.12899）：用一个持久物理速度模型经 Gaussian bridge 与扩散先验耦合，把波动方程梯度与去噪器梯度解耦，同时保留常规 FWI 的初始化与优化历史。
09-15 #2（arXiv 2609.05476）：以共成像点道集（CIG）为条件做速度与阻抗联合扩散反演——速度标签与阻抗标签解耦。
09-16 #2 VAE-FWI UQ（10.1029/2026JH001389）：反方向——把 FWI 梯度直接反传进网络权重，是本周耦合最紧的一条（⚠️ 上线日 2026-08-28，属窗口外补录）。
09-20 #4 SVGDFWI（Zenodo 21182222，UT Austin，代码包 91.4 MB 已发布）与 09-20 #5 GPR 扩散正则化 FWI 数据（Zenodo 22732464/22732465，桂林理工大学，CC BY 4.0 实测数据集）：把扩散先验当成正则项接进贝叶斯反演。

本周结论：该方向在周内从"单条方法"升级为独立多源簇，并在周末第一次拿到可复现资产（此前 09-15 的 PSG 无代码）。三种推断机制并存：后验采样 / 粒子式变分（SVGD）/ 正则化反演。

主线 2 ·【传统方法·可微/数值】可微编程（AD）成为反演默认底座，讨论重心转向"哪种 AD 更稳、更省"

09-16 #3 ADEPTS（arXiv 2609.13482）：地幔对流反演框架，给出 unrolled vs implicit 两种 AD 策略的明确收敛判据——讨论已从"能不能 AD"转向"AD 用哪种方式"。
09-16 #4 DiffSWE2d（arXiv 2609.11426，代码 github.com/ZhonghouXu/DiffSWE2d）：可微浅水方程求解器，端到端洪水/海啸建模。
09-20 #1（JAG 106519）：伴随状态算模型空间梯度 + 只对神经重参数化部分用 AD 的混合方案，并报告 GPU/CPU 内存伸缩行为——直接针对"AD 显存贵"这一具体工程痛点。
09-18 #6（GJI ggag358）：Hessian-向量积的完整拉格朗日表述与对 AD 的误差评估。⚠️ 明确指出：算子非对称时，常用拉格朗日形式 HVP 的第一项可能错误，用 L† 改写必须计入边界项——这是一个会静默产生错误梯度的问题，本周最实用的正确性提醒。

主线 3 ·【AI/地球物理】概率化 / 不确定性量化：一周内累计 7 条独立工作，已成默认而非选项

本周该方向条目：09-16 #2（VAE）→ 09-18 #3（INN）→ 09-19 #1（Epinet 认知不确定度）、#3（Whittle–Matérn 先验 + HMC）、#4（神经似然 + HMC）→ 09-20 #4（SVGD）、#6（PINN Atlas，含 conformal UQ）。

机制库在本周内扩到四种：扩散后验采样、可逆神经网络（INN）、HMC（含神经似然摊销）、SVGD 粒子式变分。

其中 09-18 #3 澳洲大陆尺度概率电阻率成像（arXiv 2609.19516）给出了本周最硬的一条成本账：2660 万条测深的概率反演压到 4.37 GPU 小时（⚠️ 作者自述，预印本未复核）。INN 的"一次前向得后验"相比扩散的迭代采样，在"每点都要不确定度"的场景下成本结构优势明显。

主线 4 ·【两类混合】成本叙事成型：省显存、省 AD、省数据

路径	代表条目	类别	关键做法
模型极致压缩 + 边缘推理	09-19 #2 XiaoNet（PNAS Nexus pgag322）	AI	PhaseNet 压缩 >93% 至 240 KB，Raspberry Pi 5 上 30 秒三通道窗推理 <1 ms（⚠️ OpenAlex 把三位作者单位全映射为 "Oklahoma Biological Survey"，与地震监测主题明显不符，机构映射错误待人工确认）
数学上避开二阶存储	09-19 #5 矩阵自由 GN CSEM（Comput Geosci 30(5):97）	传统	Hessian 不构造、不存储、不求逆，只做 HV 积 + 随机迹估计阻尼
AD 显存解耦	09-20 #1（JAG 106519）	AI×传统混合	伴随状态 + 局部 AD 混合梯度
非凸拆解绕开 AD	09-20 #7 多等级 DL 解 Helmholtz（10.1007/s10915-026-03463-w）	AI	ReLU 分级把非凸拆成凸子问题
用极稀疏实测替代密集标注	09-19 #8 FLARE-T（arXiv 2609.20451）	AI	密集有限元仿真学潜动力学 + 极稀疏实测校准（首次出现在非反演的场地反应正演代理上）

判断：本周"便宜"正式成为与"准"并列的卖点，且五条路径彼此正交（压缩 / 数学 / 显存 / 非凸 / 数据）——AI 线与传统线在"降本"这一目标上第一次正面会师。

主线 5 ·【传统方法为主】"初始模型 / 先验从哪来"——三条互相独立的答案

用另一种物理场换：09-18 #4 电磁数据驱动的多阶段"预热"FWI（10.1190/geo-2025-0168）。
用结构化地质先验：09-18 #7 地层格架约束的集合平滑多数据同化（10.1190/geo-2025-0527）。
用预训练 + 硬约束微调：09-18 #2 密度测井约束的 ResU-Net 三维重力反演（10.1190/geo-2025-0323）【AI】。
把先验写进网络结构：09-17 #3 BEIFWI 的 Sobel 层（10.1093/jge/gxag113）【AI】。

共同点：都不试图用更强的优化器硬碰非凸性，而是先把问题变简单。这与 09-17 #5 的非凸性缓解综述（GJI ggag376，传统）构成"问题 → 方案"闭环。

主线 6 ·【AI/地球物理为主】基础设施与可信度被当作一等公民

数据/接口标准化：09-15 #6 SeisBench DAS（arXiv 2609.07558）、09-15 #8 TREMORS（Agent 化多数据中心取数）、09-16 #7 中石油 220 TB 油气地震勘探大模型数据集（⚠️ 企业新闻口径，未说明基线）、09-16 #8「谛听」大模型工程化推进（⚠️ 二手来源，未验证）。
基础模型 + 少量标注：09-15 #7 SS-UNETR（75k 无标注实际数据预训练 + 2.8k 合成标注微调）、09-17 #7 DTSEC（20% 训练数据达到同等性能，跨区域退化可用少量本地样本修复）。
可信度审计：09-15 #10（ML 地震目录人类可验证性审计，⚠️ 偏差可达 20 个百分点量级）、09-17 #4 弹性波 PINN 批判性评估（154 页 44 图）、09-18 #9 明确声明"未超越所有已有方法"并报告负面消融。
⚠️ 元数据质量警告：09-18 发现 J. Seismic Exploration 的 Crossref 著录标题与出版商页面实际标题完全不符（DOI 10.36922/jse026250107，作者与日期相同但内容不相关）；09-19 复核该错配持续存在，且 10.36922/jse026210090 与之共用同一标题但作者完全不同。结论：自动文献筛选不能只依赖单一元数据提供商的标题字段。

主线 7 ·【传统方法·HPC】连续 6 天缺口，但缺口的性质在第 5–6 天发生变化

09-15 ~ 09-17：检索命中的 GPU/RTM/Devito/SPECFEM 内容几乎全为 SEO 营销页与无 DOI 博客，全部剔除。缺口非"领域不用 HPC"，而是检索路径覆盖不到 HPC 发表渠道（无 SC/ISC/IPDPS/PPoPP 类产出）。
09-18（第 4 天）：首次拿到应用侧 GPU 成本（4.37 GPU 小时 / 2660 万条测深），但系统/方法学产出仍为零。
09-19（第 5 天）：首次出现内存侧的明确工程表述（矩阵自由 GN 不构造/不存储/不求逆）。
09-20（第 6 天）：首次拿到可引用的跨平台对照基线——arXiv 2609.10368 给出 8 阶 25 点声学模板（即地震 FD 内核）在 7 种 GPU 上的 Gpts/s（Intel B70/B580/GPU MAX 1550、NVIDIA A100/RTX6000 Blackwell/H100、AMD MI325x），并对比 TinyTC 与 PyTorch/Triton；另有 BEAST 在 20,480 张 GH200 上达到 3.96 EFLOP/s（arXiv 2609.12815，AI 侧：贝叶斯神经网络），并首次出现**"不确定性并行"作为独立并行维度**。
开源栈全周零 release（Devito / SPECFEM3D / SeisSol，本系列已连续多期确认）。

三、本周精选 Top 10（AI/地球物理 6 条 + 传统方法 4 条，整体按相关性排序）

配比说明：本周原 Top 15 经新口径重新归类后，AI/地球物理 11 条、传统方法 4 条。按"AI 6 + 传统 4"配比重排为 Top 10；移出主榜的 5 条（Agentic FWI、VAE-FWI、LMGM、SDI、FWI 非凸综述）进入提名区并标注类别——其中 Agentic FWI 因摘要与全文均不可得（仅存标题与关键词）降级，SDI 与非凸综述分别属"零实验范式宣示"与"综述类"，边际信息量低于其余条目。

1. 三维深度学习参数化弹性 FWI + 伴随状态法

类别：AI/地球物理（神经重参数化为核心创新，伴随状态为传统底座）
作者/团队：期刊著录经 Crossref 核验（具体名单见 DOI 页；日报未展开）
链接：Journal of Applied Geophysics 255, 106519 · https://doi.org/10.1016/j.jappgeo.2026.106519 ·〔09-20 #1〕
方法：LSTM 对 vp/vs 做神经重参数化，模型空间梯度用伴随状态求解，只对重参数化部分使用 AD——直接绕开"AD 穿透正演导致显存爆炸"。
数据：3D 各向同性弹性多参数（摘要未给具体工区）。
代码：未声明（⚠️）。
对本项目的启发：本周唯一一条同时命中 FWI + 弹性多参数 + 3D + AD 显存工程的条目，且是"已有成熟伴随代码 + 想引入神经参数化"场景下最可直接抄的结构。
验证状态：✅ 期刊/DOI/日期经 Crossref 核验（created 2026-09-10，印刷期 2026-12）；⚠️ 具体误差改善数值在受限全文内、无代码声明，定性结论不可直接引用为性能依据。

2. 矩阵自由高斯-牛顿反演真实 CSEM 数据

类别：传统方法（二阶优化 / 数值反演工程）
作者/团队：期刊著录经 Crossref 核验（日报未展开具体名单）
链接：Computational Geosciences 30(5):97 · https://doi.org/10.1007/s10596-026-10496-5 ·〔09-19 #5〕
方法：Hessian 既不显式构造、不存储、也不求逆，只做 Hessian-向量积 + 随机迹估计阻尼；给出两种梯度预条件的对比。
数据：真实 CSEM（海洋可控源电磁）数据。
代码：未取到（⚠️ OUP 侧页面被 Cloudflare 拦截）。
对本项目的启发：把二阶方法从理论推到可落地的完整工程案例。可直接迁移到 FWI 的 Gauss-Newton 变体上，用于评估"值不值得上二阶"。
验证状态：✅ 期刊/DOI 核验；⚠️ 加速比仅给定性描述（"substantially / markedly"）无倍数，需人工看文中表格。

3. PSG：物理状态引导的扩散采样 FWI

类别：AI/地球物理（扩散生成先验）
作者/团队：arXiv 摘要页未著录（⚠️）
链接：arXiv 2609.12899 · https://arxiv.org/abs/2609.12899 ·〔09-15 #1〕
方法：持久物理速度模型 + Gaussian bridge 耦合扩散先验；物理状态由波形拟合更新并反向引导扩散，解耦波动方程梯度与去噪器梯度。
数据：OpenFWI 四族（clean / 缺失道 / 含噪）；冻结的 OpenFWI 先验零重训迁移到 Marmousi、Overthrust、BP2004 Salt。
代码：摘要页未提供 → 未验证。
对本项目的启发：本周"生成式 × FWI"簇的基线成员；"冻结先验 + 零重训迁移"这一设定对跨工区复用的可行性判断价值高于精度指标本身。
验证状态：✅ arXiv 元数据核验；⚠️ 作者单位未提供，代码未验证。

4. 地震 Hessian-向量积：完整拉格朗日表述与对自动微分的误差评估

类别：传统方法（数值数学 / 正确性）
作者/团队：GJI 著录经 Crossref 核验（日报未展开具体名单）
链接：Geophysical Journal International · https://doi.org/10.1093/gji/ggag358 ·〔09-18 #6〕
方法：推导地震 HVP 的完整拉格朗日形式，并与 AD 结果做误差对照。
数据：理论推导 + 数值对照（详见全文）。
代码：未声明。
关键结论：算子非对称时，常用拉格朗日形式的 HVP 第一项可能错误；若用 L† 改写，必须计入边界项，否则静默产生错误梯度。
对本项目的启发：本周最高性价比的一条"正确性"提醒。 若项目内已有 HVP / 二阶优化实现，建议按此文核对边界项处理。
验证状态：✅ 期刊/DOI 核验；⚠️ 具体误差数值需读全文。

5. 澳洲大陆尺度概率电阻率成像：可逆神经网络（INN）路线

类别：AI/地球物理（INN 一次前向得后验）
作者/团队：arXiv 预印本未著录单位（⚠️）
链接：arXiv 2609.19516（提交 2026-09-17）· https://arxiv.org/abs/2609.19516 ·〔09-18 #3〕
方法：INN 一次性前向得到后验，绕开扩散模型的迭代采样。
数据/规模：2660 万条航空电磁（AEM）测深，大陆尺度。
代码：未找到（⚠️）。
对本项目的启发：本周唯一给出"大尺度概率反演成本账"的条目（4.37 GPU 小时），且是概率反演四条机制路线中成本结构最优的一条。⚠️ 该路线此前四天完全未出现在检索结果中，属本周最实质的方法学新增。
验证状态：⚠️ 预印本、无 DOI、无代码、单位未著录；"4.37 GPU 小时"为作者自述，引用时必须标注为预印本自述值。

6. Stencil Computation at the Intersection of AI and HPC（模板计算：AI 与 HPC 的交汇处）

类别：传统方法（数值/HPC；AI 张量编译器仅作实现工具）
作者/团队：arXiv 未登记机构（⚠️）
链接：arXiv 2609.10368（submitted 2026-09-09，cs.DC）· https://arxiv.org/abs/2609.10368 ·〔09-20 #3〕
方法：用 AI 张量编译器（TinyTC）与 PyTorch/Triton 实现科学计算高阶模板，并与手写核对比。
数据/基准：8 阶 25 点声学模板（即地震有限差分内核）在 7 种 GPU 上的 Gpts/s：Intel B70 / B580 / GPU MAX 1550、NVIDIA A100 / RTX6000 Blackwell / H100、AMD MI325x。
代码：未取到（⚠️）。
对本项目的启发：本周 HPC 侧唯一的可引用跨平台对照基准，可直接用于"自研 FD 内核 vs 用 AI 编译器生成"的选型判断。注意它测的是单核性能，不含通信与 I/O。
验证状态：✅ arXiv 元数据核验；⚠️ 具体表格数值需读全文，机构未在 arXiv 登记。

7. PINN Atlas：物理知情神经网络的量化清算与可复现基准

类别：AI/地球物理（PINN 基准/评测）
作者/团队：Zenodo 记录与 OpenAlex 机构著录冲突（CAOS open-research programme, Santiago vs Open University of Cyprus）→ 须按作者 ORCID 0000-0002-0150-3246 主页判定（⚠️）
链接：Zenodo 10.5281/zenodo.22822967（v1.1，2026-09-18；另有同名记录 21517389 / 22834739 → 主记录需人工确认）·〔09-20 #6〕
方法：17 个用例逐一给出相对 L2 误差，按问题类型分层；含 conformal UQ 与保结构 Hamiltonian 学习。
数据/结论（分层）：平滑正问题亚 1%；反问题 4e-2；高频 Helmholtz 1.0e-1；实测数据差 2–3 个量级。
代码：MIT 代码随 Zenodo 发布（✅ 有产物，⚠️ 网页未实际下载验证）。
对本项目的启发：可直接引用的立项与拒绝依据。用于封死"PINN 替代波动方程求解器"这类提案；同时把 PINN 正确定位为约束/正则工具。
验证状态：✅ Zenodo 记录与日期核验；⚠️ 机构冲突待人工判定。

8. 电磁数据驱动的多阶段"预热"地震全波形反演

类别：传统方法（多物理场约束的 FWI 流程；无 DL）
作者/团队：⚠️ Crossref 机构串被截断（仅 "Department of Earth and Space Sciences" 与"深圳市深海油气勘探技术重点实验室"），具体高校为推测
链接：Geophysics（SEG）· https://doi.org/10.1190/geo-2025-0168 ·〔09-18 #4〕
方法：用**另一种物理场（电磁）**提供初始模型，多阶段 warm-up 进入 FWI。
数据：实测工区未在摘要指明（⚠️）。
代码：未声明。
对本项目的启发：在已有 CSEM / MT 等非地震数据的工区，这是一条"先把问题变简单"的低风险路线，比拼优化器更可能直接解决 cycle skipping。
验证状态：⚠️ 机构著录不全；工区信息需读全文。

9. TIP-INN：网络"该知道多少物理"被做成可消融的对照实验

类别：AI/地球物理（物理约束强度的消融实验设计）
作者/团队：⚠️ 设备/机构等细节在日报中标为未验证
链接：JGR: Machine Learning and Computation · https://doi.org/10.1029/2026JH001463 ·〔09-19 #1〕
方法：同一任务下对照软约束（Epinet，只学 Helmholtz 自由能）与硬约束（NICE-M，自由能 + 对偶耗散势）；输出含认知不确定度。
数据：热力学算例（详见全文）。
代码：未声明。
对本项目的启发：本周第一份把"物理约束强度"当作自变量的实验设计。此前绝大多数 PINN 类工作只报告"加约束后更好"，缺少"加多少"的刻度。可作为内部物理约束消融的模板。
验证状态：⚠️ 摘要与量化数值需读全文。

10. XiaoNet：地震震相拾取的模型蒸馏与边缘推理

类别：AI/地球物理（模型蒸馏 + 边缘部署）
作者/团队：⚠️ 机构冲突：Crossref 记 "Oklahoma Geological Survey, University of Oklahoma"，OpenAlex 记 "Oklahoma Biological Survey"（与地震监测主题明显不符），需人工确认
链接：PNAS Nexus · https://doi.org/10.1093/pnasnexus/pgag322 ·〔09-19 #2〕
方法：把 PhaseNet 压缩 >93% 至 240 KB，在 Raspberry Pi 5 上 30 秒三通道窗推理 <1 ms，并给出带宽/延迟层面的系统论证。
数据：连续波形（具体数据集见全文）。
代码：未获取（OUP 页面被 Cloudflare 拦截，需人工浏览器打开查 Data/Code Availability）。
对本项目的启发：本周"AI 从更大转向更省"的代表。若项目涉及台站侧/边缘部署，这是可直接对标的配置。⚠️ 摘要只说 "strong performance"，无 F1/拾取误差。
验证状态：✅ DOI 核验；⚠️ 机构冲突与性能数字缺失。

本周提名区（第 11–25 位，供追踪，不展开；标注类别）

序	条目	类别	来源	首次收录
11	Agentic FWI Using Local and Global Optimizers（摘要/全文不可得，降级原因见配比说明）	AI	10.1007/s11004-026-10342-5	09-17 #1
12	VAE-FWI：不依赖预训练标注的 FWI 不确定性量化（上线日 08-28 属窗口外补录；FWI 梯度直接反传进网络权重，产出形态为"一组模型 + 方差"）	AI	10.1029/2026JH001389	09-16 #2
13	LMGM：三维地震勘探轻量全局建模（Mamba/状态空间模型，线性复杂度）	AI	arXiv 2609.18294	09-17 #2
14	SDI：Structure-Driven Inversion 范式宣示（零实验零代码；作者 12 天内两篇，季度级跟踪）	传统（范式）	arXiv 2609.16536	09-16 #1
15	FWI 非凸性缓解策略综述（摘要与关键词均无 ML 词，不含 AI 章节的假设未验证）	传统（综述）	10.1093/gji/ggag376	09-17 #5
16	Pn 波层析 + 深度学习拾取（Seis-PnSn；俯冲带分段等可检验地质结论）	传统（AI 辅助）	10.1029/2026JB034108	09-16 #5
17	DiffSWE2d：可微浅水方程求解器（有 GitHub 代码）	传统（可微）	arXiv 2609.11426	09-16 #4
18	结构感知贝叶斯 FWI：扩散正则化 SVGD（Zenodo 代码包 91.4 MB）	AI	10.5281/zenodo.21182222	09-20 #4
19	时移 GPR 成像的物理引导扩散正则化 FWI 支持数据（Zenodo，CC BY 4.0）	AI	10.5281/zenodo.22732464	09-20 #5
20	4D 并行解锁百亿亿次级贝叶斯神经网络（20,480×GH200，3.96 EFLOP/s；首个"不确定性并行"维度）	AI	arXiv 2609.12815	09-20 #8
21	SS-UNETR：3D 地震图像地质特征分析的半监督预训练基础模型	AI	10.1190/GEO-2024-0788	09-15 #7
22	SeisBench DAS：分布式声学传感的机器学习框架（格式/接口标准化）	AI	arXiv 2609.07558	09-15 #6
23	多等级深度学习自适应求解高频 Helmholtz 方程	AI	10.1007/s10915-026-03463-w	09-20 #7
24	地层格架约束的集合平滑多数据同化叠后反演	传统	10.1190/geo-2025-0527	09-18 #7
25	边界增强连续表示 FWI（BEIFWI，Sobel 集成 CNN）	AI	10.1093/jge/gxag113	09-17 #3

四、本周全量条目索引（60 条位，按日报原序；含类别列）

用途：兜底检索入口。任何一条都能通过链接直达；完整方法/数据/代码/启发字段请回到对应日报。类别标注为本文件按"分类口径"对日报内容的重新归类，不改变日报原文。标注"（AI 辅助）"= AI 仅作拾取/预处理等辅助环节；标注"（可微）"= ML 框架仅作求导工具、无学习组件。

2026-09-15（窗口 09-08 ~ 09-15，7 天；自动扩展至 14 天）

#	条目	类别	链接
1	Physical-State-Guided Diffusion Sampling for FWI（PSG）	AI	https://arxiv.org/abs/2609.12899
2	Bayesian Joint Velocity and Impedance Inversion via Diffusion Models Conditioned on CIG	AI	https://arxiv.org/abs/2609.05476
3	ROMNet: hybrid reduced order modeling + ML for waveform inversion	AI	https://arxiv.org/abs/2608.25160
4	PSDWII: Physical-Structure-Driven Waveform Inversion Imaging	传统（范式）	https://arxiv.org/abs/2609.03380
5	Should All Noises Be Treated Equally: Input Noise Variability & NN Robustness	AI	https://arxiv.org/abs/2609.14504 ／ https://doi.org/10.1029/2025JH000968
6	SeisBench DAS: ML framework for Distributed Acoustic Sensing	AI	https://arxiv.org/abs/2609.07558
7	Semi-Supervised Pre-trained Foundation Model for 3D Geological Feature Analysis（SS-UNETR）	AI	https://doi.org/10.1190/GEO-2024-0788
8	TREMORS: An Agentic Assistant for Multi-Datacenter Seismic Data Acquisition	AI	https://arxiv.org/abs/2609.01777
9	A Frequency-Aware Dynamic Knowledge Distillation Framework（FADKD-Net）	AI	https://arxiv.org/abs/2609.00828
10	How much of a machine-learning earthquake catalogue can an expert verify?	AI	https://doi.org/10.31223/X5MZ2D

2026-09-16（窗口 09-09 ~ 09-16）

#	条目	类别	链接
1	Structure-Driven Inversion: A New Paradigm for Solving Inverse Problems（SDI）	传统（范式）	https://arxiv.org/abs/2609.16536
2	Physics-Constrained VAE for Uncertainty Quantification of FWI	AI	https://doi.org/10.1029/2026JH001389
3	ADEPTS: auto-differentiable framework for mantle convection inversion	传统（可微）	https://arxiv.org/abs/2609.13482
4	DiffSWE2d: differentiable Shallow Water Equations solver	传统（可微）	https://arxiv.org/abs/2609.11426 ／代码 https://github.com/ZhonghouXu/DiffSWE2d
5	Pn 波层析 + 深度学习震相拾取（Seis-PnSn）	传统（AI 辅助）	https://doi.org/10.1029/2026JB034108
6	Adaptive and accuracy-aware multiple data assimilation（ES-MDA-A2）	传统	https://arxiv.org/abs/2609.16434
7	油气地震勘探大模型高质量数据集（220 TB）	AI	https://news.cnpc.com.cn/system/2026/09/10/030202630.shtml
8	"谛听"地震大模型工程化推进（乌鲁木齐研讨班 + 山东调研）	AI	https://www.cea-igp.ac.cn/cxdt/281826.html
9	Data-driven reconstruction of 3D particle distributions using wave measurements + DL	AI	https://doi.org/10.1088/1361-665X/aea278
10	A Self-Diagnosing Structural Error-Aware Parameter Estimation Method for Earth System Models	AI	https://arxiv.org/abs/2609.16210

2026-09-17（窗口 09-10 ~ 09-17）

#	条目	类别	链接
1	Agentic Full-Waveform Inversion Using Local and Global Optimizers	AI	https://doi.org/10.1007/s11004-026-10342-5
2	LMGM: general lightweight global modeling framework for 3D seismic exploration	AI	https://arxiv.org/abs/2609.18294
3	Boundary-Enhanced Continuous Representation FWI with Sobel-Integrated CNN（BEIFWI）	AI	https://doi.org/10.1093/jge/gxag113
4	Solving the Elastic Wave Equation with PINNs: A Robust and Critical Assessment	AI	https://arxiv.org/abs/2609.07983
5	A comprehensive review of strategies to mitigate non-convexity in FWI	传统（综述）	https://doi.org/10.1093/gji/ggag376
6	Research on a DL-Based Inversion Method for Surface Wave Dispersion Spectra（INVNET）	AI	https://doi.org/10.1029/2026JH001472
7	DTSEC: Seismic Event Classifier via Fine-Tuning of a Pretrained Seismogram Foundation Model	AI	https://doi.org/10.1785/0220260150
8	PISAS v1.0: Physics-Informed Neural Surrogate for Earthquake Productivity	AI	https://doi.org/10.5194/egusphere-2026-4241
9	Bayesian inversion of multilayer CO2 migration from seismic plume observations	传统（贝叶斯反演）	https://arxiv.org/abs/2609.04937
10	Hourly U.S.-wide flood simulation beyond traditional and data-driven models（dHBV2.0MTS-MC）	AI	https://arxiv.org/abs/2609.06794

2026-09-18（窗口 09-11 ~ 09-18）

#	条目	类别	链接
1	Generative AI for seismic signal processing and imaging: status and perspectives	AI（综述）	https://doi.org/10.1007/s11430-025-2038-7
2	Enhanced 3D gravity inversion using ResU-Net with density-logging constraints	AI	https://doi.org/10.1190/geo-2025-0323
3	Continental-scale probabilistic resistivity imaging of Australia using DL（INN）	AI	https://arxiv.org/abs/2609.19516
4	Multistage warm-up seismic FWI informed by electromagnetic data	传统	https://doi.org/10.1190/geo-2025-0168
5	FWI Cycle-Skipping Mitigation with DTW, Part 2: An Intermediate Signal Approach	传统	https://doi.org/10.1007/s00024-026-04116-7
6	Seismic Hessian vector products: Lagrangian formulation and AD error assessment	传统	https://doi.org/10.1093/gji/ggag358
7	Stratigraphy-guided ensemble smoother multidata assimilation for poststack inversion	传统	https://doi.org/10.1190/geo-2025-0527
8	Nonlinear seismic inversion in triaxial stress-induced anisotropic media	传统	https://doi.org/10.1093/gji/ggag366
9	Ensembles of lightweight U-Net with EfficientNet encoders for seismic segmentation	AI	https://doi.org/10.36922/jse026260116
10	Deep reinforcement learning for strategic drilling	AI	https://doi.org/10.1190/int-2025-0046

2026-09-19（窗口 09-12 ~ 09-19；arxiv geo-ph 主窗口仅 19 条）

#	条目	类别	链接
1	How Much Physics Should a Neural Network Know?（TIP-INN / NICE-M）	AI	https://doi.org/10.1029/2026JH001463
2	Edge seismic phase picking: Model distillation for multimodal early-warning（XiaoNet）	AI	https://doi.org/10.1093/pnasnexus/pgag322
3	Bayesian Framework with Geology-Informed Structural Priors for Tomography + UQ	传统（贝叶斯反演）	https://doi.org/10.1093/gji/ggag374
4	Neural Surrogate HMC: Neural Likelihoods for HMC in Simulation-Based Inference	AI	https://doi.org/10.1029/2025JH001164
5	A matrix-free Gauss-Newton inversion of realistic CSEM data	传统	https://doi.org/10.1007/s10596-026-10496-5
6	Automatic segmentation of microseismic monitoring signal under low SNR（SEU-Net）	AI	https://doi.org/10.1371/journal.pone.0358562
7	Learning-Based Methods and the Future of Numerical Ocean and Sea-Ice Modeling	AI（综述）	https://doi.org/10.1146/annurev-marine-040125-074353
8	Seismic Site Response Prediction from Sparse Observations（FLARE-T）	AI	https://arxiv.org/abs/2609.20451
9	Early warning of mine seismic events via spatiotemporal information transformation（SDPM）	AI	https://doi.org/10.1038/s44304-026-00272-x
10	Enhanced View of the Mw 6.4 Petrinja Sequence Using Deep Learning（PESMLC）	AI	https://doi.org/10.26443/seismica.v5i2.1770

2026-09-20（窗口 09-13 ~ 09-20）

#	条目	类别	链接
1	Three-dimensional deep learning parameterized elastic FWI with adjoint-state method	AI	https://doi.org/10.1016/j.jappgeo.2026.106519
2	Physics-guided deep learning for subsurface characterization: A critical review	AI（综述）	https://doi.org/10.1016/j.jappgeo.2026.106515
3	Stencil Computation at the Intersection of AI and HPC	传统（HPC）	https://arxiv.org/abs/2609.10368
4	Structure-aware Bayesian FWI via diffusion-regularized SVGD（SVGDFWI）	AI	https://doi.org/10.5281/zenodo.21182222
5	Supporting GPR Data for Time-Lapse Imaging … Diffusion-Regularized FWI	AI	https://doi.org/10.5281/zenodo.22732464
6	A Physics-Informed Neural Network Atlas	AI	https://doi.org/10.5281/zenodo.22822967
7	The Adaptive Solution of High-Frequency Helmholtz Equations via Multi-Grade DL	AI	https://doi.org/10.1007/s10915-026-03463-w
8	4D Parallelism Unlocks Exascale Bayesian Neural Networks	AI	https://arxiv.org/abs/2609.12815
9	Bayesian Gaussian Process Framework for Discrete Inversion of 2D Gravity Data（InDIA）	AI（ML·高斯过程）	https://doi.org/10.1093/gji/ggag375
10	Advances in Deep Learning Applications for Slow Earthquake Research	AI（综述）	见日报原文（09-20）

五、本周演化：重复 / 升级 / 新增方向（分两线）

5.A AI/地球物理线

重复（跨日再次命中，只保留首次收录）

LMGM（2609.18294）——09-17 首收，09-19、09-21 复现，仍为 v1、无代码、无新增实验。
澳洲电阻率成像（2609.19516）——09-18 首收，09-19、09-20 复现，同上。

升级（前日"信号"→ 后续拿到可核验证据）

升级项	轨迹	结果
XiaoNet	09-19 收录时"摘要未获取、性能数字缺失" → 09-22 经 OpenAlex 取到完整摘要（>93% 压缩 / 240 KB / 亚毫秒）	✅ 数字可用；⚠️ 同时暴露 OpenAlex 机构映射错误
PINN 定位	09-17 #4 批判性评估（定性）→ 09-20 #6 PINN Atlas（17 例逐例误差）	✅ 从"定性争论"升级为"有公开基准可引用"

新增方向（此前未出现）

🆕 模型蒸馏 + 边缘推理进入地震监测（XiaoNet）
🆕 "网络该知道多少物理"做成可消融自变量（TIP-INN vs NICE-M）
🆕 神经似然 + HMC 的摊销式贝叶斯（Neural Surrogate HMC）
🆕 神经重参数化 + 伴随状态的 3D 弹性 FWI（JAG 106519）
🆕 可复现的 PINN 方法图谱 / 精度分层基准（PINN Atlas）
🆕 SVGD 粒子式变分推断进入贝叶斯 FWI（SVGDFWI，概率化第 4 种机制）
🆕 "不确定性并行"作为独立并行维度（BEAST）
🆕 输入表示域的系统性消融基准（去噪，以下游任务为指标）

5.B 传统方法线

重复

SDI（2609.16536）——09-16 首收，09-19、09-20 连续复现无更新（范式宣示类，归传统线跟踪）。

升级

升级项	轨迹	结果
Pn 波层析（Seis-PnSn）	09-15 列入"延伸观察"，日期未验证 → 09-16 经 Crossref + 中科院地质地球所官方页核实	✅ 拿到 DOI、卷期、上线日、模型名、20 余万条 Pn 到时数据 → 由延伸观察升入主榜（传统方法 + AI 辅助拾取）
PSDWII → SDI 范式	09-15 #4 只是"虚源投影"单点方法 → 09-16 #1 被正式提升为独立范式（含 MSDPII、PSDBP 两分支）	✅ 相关性上调，但仍零实验零代码
HPC 缺口	09-15 ~ 09-18 全是营销页 → 09-18 首次拿到应用侧 GPU 小时数 → 09-19 内存侧表述（矩阵自由 GN）→ 09-20 跨平台 Gpts/s 基线	⚠️ 性质从"缺信息"变为"有应用侧基线，仍无系统侧方法学"
元数据错配	09-18 首次发现 J. Seismic Exploration Crossref 标题与出版商页面不符 → 09-19 复核依然不符，且新增共用标题但作者不同的记录	❌ 确认该刊 Crossref 著录在本窗口内持续不可靠

新增方向

🆕 矩阵自由二阶优化落地到电磁反演（随机迹估计阻尼 + 预条件对比的完整工程案例）
🆕 HVP 拉格朗日表述的边界项正确性警告（会静默产生错误梯度）
🆕 DTW 中间信号法缓解 cycle skipping（Part 2）
🆕 可微求解器拿到可访问代码（DiffSWE2d，GitHub）

5.C 两线交叉观察

"降本"目标上两线会师：AI 线（压缩/蒸馏、神经参数化降显存）与传统线（矩阵自由二阶、AD 策略选择）在"省算力"上给出互补而非竞争的方案（见主线 4 表）。
AI 辅助型条目（如 Seis-PnSn）是两线的天然接口：传统层析为主体、DL 拾取为输入端。
正确性审计在两线同时出现：AI 线（PINN 批判性评估、ML 目录审计）与传统线（HVP 边界项）——"你确定你算的是对的吗"是本周两线共同的一等问题。

六、本周趋势总结（分两线）

6.A AI/地球物理线

生成式先验正在从"替代 FWI"转向"与 FWI 协作"，技术关键词是解耦（波动方程梯度 ↔ 去噪器梯度、速度标签 ↔ 阻抗标签）。这比 2023–2024 年那批"U-Net 直接回归速度场"在可解释性与可控性上进了一步。
概率化/不确定性从选项变成默认：连续 6 天、7 条独立工作指向同一结论——做反演而不给不确定度，正在变成不被接受的默认状态。
AI 的重心开始从"更大"向"更省"双向分裂（XiaoNet 240 KB 边缘推理 vs 大模型/基础模型工作）。不是所有问题都要靠堆卡解决。
"物理约束的硬保证"开始取代"损失惩罚"（PISAS 解析解码器把物理一致性变成结构上不可能违反；Sobel 层把边界先验变成结构）——比"加一个物理损失项"高一个层级。
"物理约束到什么程度"首次被当成可消融的自变量（TIP-INN vs NICE-M）。
可信度审计成为一等公民：ML 目录可验证性（偏差可达 20 个百分点量级）、PINN 批判性评估（154 页 44 图）、"哪些方法上了实测数据"。
基础设施成为主战场：220 TB 数据集、"谛听"、SeisBench DAS 标准化、TREMORS Agent 化取数——瓶颈正从算法侧迁移到数据供给与算力调度侧。
DL 拾取的下游价值首次形成完整闭环（5 年 DL 拾取量 > 58 年人工目录累积量 → 可检验地质结论）；评价 AI-FWI 不应只看整体 SSIM，要看深层、盐下、强衰减等尾部构造。
稀有事件/尾部样本是"物理嵌入"相对"纯数据驱动"的真正优势区（≥100 年一遇洪峰上量级误差降 34%，整体技巧与纯 AI 相当）。

6.B 传统方法线

可微编程（AD）从"技巧"变成"默认底座"，讨论重心已从"能不能 AD"转向"AD 的哪一种方式更稳/更省"（ADEPTS 的 unrolled vs implicit 判据）。这是领域技术成熟的标志。
二阶优化的工程化落地：矩阵自由 GN（不构造/不存储/不求逆 + 随机迹阻尼 + 预条件对比）给出完整案例。
正确性优先：HVP 边界项问题（静默错误梯度）是本周传统线最实用的提醒。
"先把问题变简单"成为对抗非凸性的主流姿势：多物理场初始模型、地质先验、多阶段 warm-up——与优化器层面的努力互补。
反演的"精度—算力"权衡开始被显式建模为用户可调接口（ES-MDA-A2 的"目标准确度 + 最大同化次数"两个旋钮）。
⚠️ HPC 侧连续 6 天无系统/方法学产出，第 6 天才拿到可引用的跨平台实测基线。缺口不是"地球物理不用 HPC"，而是"检索路径覆盖不到 HPC 发表渠道"——信息源问题，不是领域问题。
⚠️ 元数据质量是需要警惕的信号：Crossref 对 J. Seismic Exploration 的著录持续错位。自动筛选必须交叉验证出版商页面。

6.C 综合判断

本周两线的产出比约为 44:16（AI:传统）。AI 线在"生成式先验、概率化、降本"三条线上多点开花；传统线的贡献集中于底座正确性与工程化（HVP、矩阵自由 GN、AD 策略、跨平台基线）。两线不是替代关系：AI 线的每一条"更省"主张，背后都站着一个传统线的工程前提。

七、对项目的行动建议（本周合并版）

课题口径仍为默认的 AI + HPC + 地震数据处理 + FWI。以下按"投入成本 × 预期收益"排序，均为建议，未执行任何操作。括号内为所属线别。

A. 立即可做（低风险、低成本，1–3 天）

核对现有二阶/伴随实现的 HVP 边界项——依据 GJI ggag358（传统线）。这是本周唯一一条可能导致静默错误梯度的提醒，优先级最高。
建立"物理约束强度"消融模板——参照 TIP-INN vs NICE-M 的设计（AI 线），把软约束与硬约束做成同一任务下的对照臂。
把 DiffSWE2d、SVGDFWI、PINN Atlas 三份可复现资产加入候选池（分别对应可微求解器〔传统/可微〕、贝叶斯 FWI〔AI〕、PINN 基准〔AI〕）。三者均有可访问产物，至少值得跑通一次环境。
在评测清单里加入两条硬性要求：① 尾部构造（深层/盐下/强衰减）单独报指标；② 去噪类任务补下游指标（检测率、到时、极性）。
把"合成排名不能代表实测排名""元数据标题不可全信"两条写进内部文献筛选规范。

B. 需要评估（有收益但需先做可行性判断，1–4 周）

评估 INN 路线做概率反演的可行性——依据 09-18 #3（2660 万条测深 / 4.37 GPU 小时，作者自述）。重点不是精度，是**"每点都要不确定度"场景下的成本结构**（AI 线）。
为 3D 体数据长程依赖任务做 LMGM（Mamba）对照——线性复杂度是本周与算力账最直接相关的一条（AI 线）。
评估"用电磁/其他物理场换 FWI 初始模型"是否在现有工区可行——依据 09-18 #4（传统线）。
评估自研 FD 内核 vs AI 张量编译器的性价比——依据 09-20 #3 的 7 平台 Gpts/s 基线（传统/HPC 线）。

C. 仅记录（暂不投入）

SDI / PSDWII 类"零实验零代码"的范式宣示（传统线）——季度级跟踪，不作立项依据。
Agentic FWI（10.1007/s11004-026-10342-5）（AI 线）——摘要与全文均不可得，在读到全文前不做任何技术判断。
企业新闻口径的效率数字（如 220 TB 数据集的"效率提升 9–12 倍"）——引用时必须标注来源性质。

D. HPC 侧的具体提醒

建议补订稳定的 HPC 信息源：SC / ISC / IPDPS / PPoPP 会议论文、NVIDIA GTC 技术日程、SEG/EAGE 年会技术程序、SPECFEM / Devito / SeisSol 官方 release notes 与 GitHub releases。本周 6 天的缺口本质是检索路径问题。
开源栈下周复查项（本周实测均无新版本）：Devito v4.8.23 / 2026-08-07；SPECFEM3D v4.1.1 / 2024-03-15；SeisSol v1.3.2 / 2025-06-17。
注意"内存而非 FLOPs"这一信号：本周已出现矩阵自由 GN（不存储 Hessian）。若内部在做架构选型，把内存占用作为硬约束而非事后优化项。

八、未解决项 / 需人工确认

8.1 结构性问题（本周持续）

⚠️ 模板变量连续未注入：{{date}} / {{lookback_days}} / {{history_dir}} / {{lookback_reports}} / {{project}} 全部为原始占位符，6 份日报全部沿用默认值（7 天 / 扩展 14 天 / 默认课题语境）。建议修改自动化配置注入实际值。
project 未指定：所有"对项目的启发"均按默认课题语境撰写，若实际项目有具体工区、正反演代码或集群环境，请补充后重跑。
历史基线薄弱：lookback_reports = 7，但 09-15 时目录内 0 份、09-20 时仅 5 份。建议积累 5–7 份后再评估"新增方向"的统计意义。

8.2 代码/数据可用性（本周统计）

本周 60 条位中，明确给出可访问代码/数据链接的仅 4 条：DiffSWE2d（GitHub，传统/可微）、SVGDFWI（Zenodo，AI）、GPR 扩散正则化数据（Zenodo，AI）、PINN Atlas（Zenodo + MIT，AI）。
其余条目摘要页均未提供仓库链接，请勿据此认定开源。
⚠️ SVGDFWI 的 Zenodo 记录未明示 license，再分发前必须确认；GPR 数据存在双 DOI（22732464 / 22732465），主记录需人工判定。

8.3 跨期悬置项（截至 2026-09-20，含悬置天数）

项	悬置	建议动作
Princeton RSE WebGPU/WGSL 可移植地震求解器	第 6 次未验证（09-15 起）	建议人工浏览器确认一次后结案，或直接放弃
Science China Earth Sciences 生成式 AI 综述摘要（10.1007/s11430-025-2038-7）	连续第 3 天未获取	09-21 已拿到作者/单位/出版日（电子科技大学 / Mansoura / 清华，2026-09-14），仅摘要缺失；需人工浏览器打开一次并回填
IEEE TGRS 多参数地震反演 DOI	09-17 起悬置	只有南阳理工学院宣传稿，确认 DOI 前不得引用
DP-Inv 作者数分歧（Crossref 4 位 vs Springer 目次 3 位）	09-15 起	人工确认
J. Seismic Exploration 元数据错配	第 2 天（已复核仍存在）	结论已定型：该刊 Crossref 著录不可靠，自动筛选必须交叉验证出版商页面
OUP（academic.oup.com）Cloudflare 拦截	09-20 起	GJI 多条代码/数据声明只能人工浏览器打开
DTW-ISA 的计算开销	09-18 起	DTW 为 O(N·M)，长记录多道下可能成为瓶颈，需读全文确认能否上生产链路
FDCompGraph 是否开源 / aea999 多保真度参数化	09-19 起	无新证据
XiaoNet 机构冲突（Crossref vs OpenAlex）	09-20 起	到出版商页或作者主页确认
SDPM 单位可疑（OpenAlex 映射问题）	09-20 起	到 nature.com 页面确认
PESMLC 目录是否发布	09-20 起	到 seismica 页面确认
Applied Geophysics 09-09 那批论文的摘要	持续	出版商未向 Crossref/OpenAlex 提供结构化摘要，只能人工取 PDF
Agentic FWI 摘要（10.1007/s11004-026-10342-5）	09-17 起	全文闭源，连续多期无法推进，建议人工判断是否继续投入检索预算
eDWI（geo-2025-0147）摘要截断	09-18 起	Crossref 与 OpenAlex 均在 "applications using seismic and other wave" 处断掉，需从出版商获取完整摘要
研究机构缺失的 arXiv 条目（2609.10368、2609.12815、2609.12115 等）	09-20 起	取 PDF 首页人工核对

8.4 需人工确认的性能数字（本周）

本周主榜 60 条位中，给出可直接引用量化数字的仅约 1/5，其余为定性表述（"substantially""more accurate""promising"）。已逐条在日报中标注。任何基于本周条目做的选型决策都应以自复现为准，不要直接引用摘要里的形容词。

九、检索说明与本文件生成方式

本文件不是检索产物。生成过程为：读取 AI每日总结_2026-09-15.md ~ AI每日总结_2026-09-20.md 六份原文 → 按 ISO 周归并 → 抽取各期"〇对比""趋势总结""未解决项" → 合并同一条目的升级轨迹 → 按"AI/地球物理 + 传统方法"两分类重新归类并标注 → 按 AI 6 + 传统 4 配比重排 Top 10 → 输出本文件。未访问任何外部数据源。
两类条数分布：60 条位中 AI/地球物理 44 条 / 传统方法 16 条（每日分布：09-15 为 9:1、09-16 为 5:5、09-17 为 8:2、09-18 为 5:5、09-19 为 8:2、09-20 为 9:1）。精选 Top 10 配比 6:4；传统方法条数充足（16 条 ≥ 4），无需"凑数"。
历史重复/升级/新增：本周期为系列起点，无前序周报可比；周内跨日重复 3 条（SDI〔传统〕、LMGM〔AI〕、INN 澳洲〔AI〕）、升级项分两线列于第五节、新增方向 AI 线 8 项 + 传统线 4 项。
分类判定说明（边界条目的归类原则）：① AI 仅作辅助（如 DL 拾取 + 层析的 Seis-PnSn）→ 传统（AI 辅助）；② ML 框架仅作求导/计算工具、无学习组件（如 ADEPTS、DiffSWE2d）→ 传统（可微）；③ SDI 等不以 DL 为核心的范式宣示类 → 传统（范式）；④ 高斯过程等经典统计学习为核心 → AI（ML）；⑤ BeJNV 混合结构（JAG 106519）按"核心创新在哪侧"归 AI，并在类别行注明传统底座。归类为整理动作，不代表对论文创新性的判断；若与原文自述不符，以原文为准。
⚠️ 2026-10-08 变更：按用户要求，本周期 6 份日报已随全部 12 份历史日报移出主目录，现留存于工作区 .回收站_日报_2026-10-08/ 与外部备份 /home/liguolong/geo_scratch/backup_日报_2026-10-08/（删除前校验一致）。"回溯入口"请改到上述两处查阅。
诚实性声明：
- 所有链接、作者、机构、日期、数字均转述自日报原文，日报未验证的一律沿用"未验证/需人工确认"标注，本文件未做任何新的推断或补齐。
- 日报中被标注为"依据标题推断""企业新闻口径""二手来源"的内容，在本文件中保持原标注。
front matter 说明：周报使用 tags: ["AI每周总结"] 与 category: "AI每周总结"。若站点分类体系（taxonomy）需要与日报保持同一 category，请把 category 改为 "AI每日总结"，其余字段不变。
只读优先：本文件生成过程未执行任何写入以外的操作，未提交、未删除、未覆盖任何既有文件。

AI 提示词

Tue, 15 Sep 2026 00:00:00 GMT

AI 提示词

1、每日定时任务提示词

你是资深地球物理方向的学者，熟悉 AI/深度学习、HPC、地震数据处理、全波形反演 FWI。

今天是 {{date}}，格式 YYYY-MM-DD。

任务：检索 {{lookback_days}} 天内 AI + 地球物理相关或者传统方法进展，筛选 10 条最相关内容；其中传统地球物理方法约 4 条（建议 3–5 条），AI/深度学习 + 地球物理约 6 条（建议 5–7 条）。若可验证的传统方法不足约 4 条，则按实际可验证条数列出并说明原因，不凑数。

读取 {{history_dir}} 中最近 {{lookback_reports}} 份历史总结，对比重复、升级、新增方向；分别对比 AI/地球物理与传统方法的重复、升级、新增方向，并在条目中标注“AI/地球物理”或“传统方法”。

严格要求：

只依据可验证来源，不编造链接、作者、团队、结论、数据或代码。

若信息不足或无法验证，标注“未验证/需人工确认”，不要凑数。

若不足 10 条，列出实际条数并说明原因；传统方法不足约 4 条时同样说明。

传统方法定义：以物理/数学/数值/信号处理/反演/成像/层析/地震干涉/走时/振幅等为核心，不以深度学习/机器学习为主要创新；AI 仅作辅助、对比或后处理的，归为传统方法。

AI/地球物理定义：以深度学习、机器学习、神经网络、基础模型、生成模型、强化学习等为核心创新的地球物理研究。

输出必须是一个完整 Markdown 文件全文，第一行必须是 YAML front matter，前面不要添加任何解释。

文件名：AI每周总结_{{date}}.md

YAML front matter 固定为：

title: "AI每周总结-地球物理 ({{date}})"
published: {{date}}
tags: ["AI每周总结"]
category: "AI每周总结"
draft: false

正文要求：

每条包含：标题、作者/团队、链接、方法、数据、代码、类别（AI/地球物理 或 传统方法）、对 {{project}} 的启发、验证状态。

按相关性排序；在整体排序中保留传统方法约 4 条、AI/地球物理约 6 条；若实际分布偏离，注明原因。

最后给出：今日趋势总结（分别总结 AI/地球物理与传统方法）、对 {{project}} 的行动建议、未解决项/需人工确认、检索说明（含两类条数分布、历史重复/升级/新增、不足原因）。

若平台支持写文件，将内容写入 AI每日总结_{{date}}.md；若不支持，只输出文件全文。

只读优先；涉及提交作业、删除、覆盖模型等操作，只给命令草稿，等待人工确认

deepseek harness 安装和使用

Tue, 15 Sep 2026 00:00:00 GMT

deepseek harness 安装和使用

方法一：直接使用node.js 安装

#下载位置：https://nodejs.org/en/download
# 需要已安装好node.js node -v

# 直接安装
npx @deepseek-ai/dsh web

# 编译安装
git clone https://github.com/deepseek-ai/deepseek-harness.git
cd deepseek-harness
pnpm install
pnpm run build # 准备仓库产物
pnpm dsh web   # 直接使用这些已构建产物

在浏览器中打开

输入API密钥

方法二：在vscode中使用并自动安装（在remote ssh远程时工作存在问题）

方法三：使用dsh-tui 然后连接workbuddy 免费用token（推荐）

#下载位置：https://nodejs.org/en/download
# 需要已安装好node.js node -v

# 安装dsh 和 dsh-tui
# https://dshtui.com/getting-started/
npm install -g @deepseek-ai/dsh @deepseek-harness-tui/dsh-tui

# 安装workbuddy 按照官网教程即可
https://www.workbuddy.cn/events/invite?inviteCode=cdqfmscx2z

# 安装wrokbuddy-conect插件（选择版本）
# https://github.com/dingminhua/dsh-connect-workbuddy
dsh plugin --profile web add dsh-connect-workbuddy     # Web
dsh plugin --profile dsh-tui add dsh-connect-workbuddy # TUI
dsh plugin --profile desktop add dsh-connect-workbuddy # desktop

# 运行
dsh web # 网页
dsh-tui # TUI

在vscode 的对应插件

在dsh-tui/setting中修改各种设置

web 设置wrokbuddy

# 启动web页面并设置
dsh web
# 验证workbuddy状态
dsh plugin --profile web exec dsh-connect-workbuddy status
dsh plugin --profile dsh-tui exec dsh-connect-workbuddy status

#对于服务器，或者不详安装workbuddy 可以把已经登录workbuddy的信息粘贴
cp -r  其他位置的~/.local/share[~/.config]/CodeBuddyExtension   ~/./local/share/CodeBuddyExtension

# 输出示例
CN (domestic): signed in as 没脾气的鬼才
  Access token expires 2026-10-16T08:48:36.883Z (refresh is automatic)
  Local accounts: 1
  Remaining credit: 3552
Global: signed out
  Local accounts: 0
Host bundle: stale heartbeat (DSH process exited)
Client card: load failures are logged to the browser console only; the host providers are unaffected.

在tui中设置/models

总的命令

# 网络设置
export all_proxy=http://127.0.0.1:7890
# 删除老的包
rm -rf ~/.dsh ~/.npm ~/.dsh-tui ~/.nvm ~/.dsh-debug
# 下载并安装 nvm：
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.3/install.sh | bash
# 代替重启 shell
\. "$HOME/.nvm/nvm.sh"
# 下载并安装 Node.js：
nvm install 24
# 验证 Node.js 版本：
node -v # Should print "v24.21.0".
# 下载并安装 pnpm：
corepack enable pnpm
# 验证 pnpm 版本：
pnpm -v
# 安装 deepseek harness 以及tui
npm install -g @deepseek-ai/dsh@0.2.0-rc.2 @deepseek-harness-tui/dsh-tui@0.14.0
dsh --version
dsh-tui --version
# 验证 
dsh plugin --profile web     add dsh-connect-workbuddy@4.3.2
dsh plugin --profile dsh-tui add dsh-connect-workbuddy@4.3.2
dsh plugin --profile web     exec dsh-connect-workbuddy status
dsh plugin --profile dsh-tui exec dsh-connect-workbuddy status

利用公开模板建站

Fri, 11 Sep 2026 00:00:00 GMT

1、安装node.js

# 下载并安装 nvm：
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.3/install.sh | bash

# 代替重启 shell
\. "$HOME/.nvm/nvm.sh"

# 下载并安装 Node.js：
nvm install 24


corepack enable
corepack prepare pnpm@11 --activate

# 验证 Node.js 版本：
node -v # Should print "v24.21.0".

# 验证 npm 版本：
npm -v # Should print "11.19.0".

2、安装包和运行

# https://github.com/saicaca/fuwari
pnpm install
pnpm dev

参考来源

https://bysansheng.cn/posts/fuwari-%E6%90%AD%E5%BB%BA%E6%95%99%E7%A8%8B/

https://fuwari.vercel.app/

https://github.com/afoim/fuwari

https://blog.isyyo.com/posts/fuwari_tutorial/

Linux 服务器本地转发

Wed, 12 Aug 2026 00:00:00 GMT

Linux 服务器本地转发

# 查看本地端口情况
ss -tlnp | grep 1080

#pkill -9 -u liguolong

# 在 WSL 中执行 - 创建 SOCKS5 服务
ssh -fN -D 1080 localhost

# 在 WSL 中测试代理是否工作
curl --socks5-hostname localhost:1080 https://www.baidu.com -I

# 在 WSL 中执行 - 将 SOCKS5 服务转发到远端
ssh -fN -R 1080:localhost:1080 liguolong@172.19.133.164

# SSH 登录远端后执行
curl --socks5-hostname localhost:1080 https://www.baidu.com -I

#代理解析
export http_proxy="socks5h://localhost:1080"
export https_proxy="socks5h://localhost:1080"
export all_proxy="socks5h://localhost:1080"

# 本地解析 DNS（需要本地能解析域名）
export http_proxy="socks5://localhost:1080"
export https_proxy="socks5://localhost:1080"

ssh -fN -D 1080 localhost
ssh -fN -R 1080:localhost:1080 lyy-node3
ssh lyy-node3
export http_proxy="socks5h://localhost:1080"
export https_proxy="socks5h://localhost:1080"
export all_proxy="socks5h://localhost:1080"

本地端口

服务器端口

VScode调试 CUDA+CMAKE

Wed, 12 Aug 2026 00:00:00 GMT

VScode调试 CUDA+CMAKE

在vscode中进行运行调试cuda程序

Launch.json

{
  "version": "0.2.0",
  "configurations": [
    {
      "name": "CUDA C++: Launch",
      "type": "cuda-gdb",
      "request": "launch",
      "program": "${workspaceFolder}/build/gpu2dfd",
      "args": "xx",
      "preLaunchTask":"Build"
    },
  ]
}

Tasks.json

{
  "version": "2.0.0",
  "options": {
  "cwd": "${workspaceFolder}/build" // 进入 build 文件夹
  },
  "tasks": [
    {
     // 运行 cmake .. 命令
      "type": "shell",
      "label": "cmake",
      "command": "cmake",
      "args": [
        ".."
      ]
    },
    {
      // 运行 make 命令
      "label": "make",
      "group": {
        "kind": "build",
        "isDefault": true
     },
      "command": "make",
      "args": [
      ]
    },
    {
      "label": "Build",
     "dependsOrder": "sequence", // 按列出的顺序执行任务依赖项
      "dependsOn":[
        "cmake",
        "make"
      ]
    }
  ]
}

Cmake

# complie the FDTD CUDA code with cmake
cmake_minimum_required(VERSION 3.10)
project(GPU2DFD LANGUAGES CUDA CXX)

# set the debug mode
set(CMAKE_BUILD_TYPE Debug)

# check the cuda language
include(CheckLanguage)
check_language(CUDA)
if(CMAKE_CUDA_COMPILER)
  message(STATUS "Find CUDA !")
else()
  message(FATAL_ERROR "Not found CUDA!")
endif()
set(CMAKE_CUDA_STANDARD 11)
set(CMAKE_CUDA_ARCHITECTURES 50 60 70)
# add the source file
add_executable(gpu2dfd gpu2dfd.cu)

podman 换源与示例

Sun, 12 Jul 2026 00:00:00 GMT

podman 换源与示例

一、docker国内源

sudo cp  /etc/containers/registries.conf /etc/containers/registries.conf.bak
$ sudo vim /etc/containers/registries.conf

在末尾添加 配置文件也可以/home/lgl/.config/containers/storage.conf

[[registry]]
# 需要被加速的原始仓库
prefix = "docker.io"
# 实际访问的仓库地址，通常与 prefix 相同
location = "docker.io"

# 第一个镜像源：中科大（推荐）
[[registry.mirror]]
location = "3uscr8bc.mirror.aliyuncs.com"
# 是否允许不安全的HTTP连接，国内主流源都支持HTTPS，保持false即可
insecure = false

$ sudo systemctl restart podman
$ podman info #检查是否成功

二、检查是否成功

$ podman pull hello-world
$ podman run hello-world

三、删除镜像和容器

# 删除容器
podman rm -af
# 删除所有镜像（谨慎使用！）
podman rmi -af

#进入容器的交互式终端
podman exec -it container_name /bin/bash

#列出当前正在运行的容器
podman ps

#列出所有容器（包括已停止的容器）
podman ps -a

#停止一个或多个容器
podman stop container_name

makefile：管理项目基本用法

Fri, 12 Jun 2026 00:00:00 GMT

makefile：管理项目基本用法

1、基本介绍

使用 GCC 的命令行进行程序编译在单个文件下是比较方便的，当工程中的文件逐渐增多，甚至变得十分庞大的时候，使用 GCC 命令编译就会变得力不从心。这种情况下我们需要借助项目构造工具 make 帮助我们完成这个艰巨的任务。 make是一个命令工具，是一个解释makefile中指令的命令工具。

make工具在构造项目的时候需要加载一个叫做makefile的文件，makefile关系到了整个工程的编译规则。一个工程中的源文件不计数，其按类型、功能、模块分别放在若干个目录中，makefile定义了一系列的规则来指定哪些文件需要先编译，哪些文件需要后编译，哪些文件需要重新编译，甚至于进行更复杂的功能操作，因为makefile就像一个Shell脚本一样，其中也可以执行操作系统的命令。

makefile带来的好处就是——“自动化编译”，一旦写好，只需要一个make命令，整个工程完全自动编译，极大的提高了软件开发的效率。makefile文件有两种命名方式 makefile 和 Makefile，构建项目的时候在哪个目录下执行构建命令 make这个目录下的 makefile 文件就会别加载，因此在一个项目中可以有多个 makefile 文件，分别位于不同的项目目录中。

2、基本用法

命名：makefile Makefile (make) 命令

**1 个规则：**依赖条件（一个tab缩进）命令

目标的时间必须晚于依赖条件的时间，否则，更新目标
依赖条件如果不存在，找寻新的规则去产生依赖条件。 ALL：指定 makefile 的终极目标。否则终极目标是第一个目标

2 个函数：

src = $(wildcard ./*.c): 匹配当前工作目录下的所有.c 文件。将文件名组成列表，赋值给变量 src。
src = add.c sub.c div1.c

obj = $(patsubst %.c, %.o, $(src)): 将参数3中，包含参数1的部分，替换为参数2。
obj = add.o sub.o div1.o

clean:	(没有依赖)
    -rm -rf $(obj) a.out    “-”：作用是，删除不存在文件时，不报错。顺序执行结束。
    make clean -n  模拟执行

3 个自动变量：

$@: 在规则的命令中，表示规则中的目标。

$^: 在规则的命令中，表示所有依赖条件。

$<: 在规则的命令中，表示第一个依赖条件。
如果将该变量应用在模式规则中，它可将依赖条件列表中的依赖依次取出，套用模式规则。

模式规则：

%.o:%.c
   gcc -c $< -o $@

**静态模式规则：**大目标是obj，这个obj就是各种.o文件，然后%.o就是具体的解释，而%.c就是对应同样名字的.c文件

$(obj):%.o:%.c
   gcc -c $< -o $@

**伪目标：**告诉make，.PHONY：后面跟着的名称不是指文件名

.PHONY: clean ALL

参数：
    -n：模拟执行make、make clean 命令。

    -f：指定文件执行 make 命令。                xxxx.mk

3、详细用法

3.1.、规则

Makefile的框架是由规则构成的。make命令执行时先在Makefile文件中查找各种规则，对各种规则进行解析后运行规则。规则的基本格式为：

target1,target2...: depend1, depend2, ...
    command
    ......
    ......

每条规则由三个部分组成分别是目标(target), 依赖(depend)和命令(command)。

命令(command): 当前这条规则的动作，一般情况下这个动作就是一个 shell 命令
- 例如：通过某个命令编译文件、生成库文件、进入目录等。
- 动作可以是多个，每个命令前必须有一个Tab缩进并且独占占一行。
依赖(depend): 规则所必需的依赖条件，在规则的命令中可以使用这些依赖。
- 例如：生成可执行文件的目标文件（*.o）可以作为依赖使用
- 如果规则的命令中不需要任何依赖，那么规则的依赖可以为空
- 当前规则中的依赖可以是其他规则中的某个目标，这样就形成了规则之间的嵌套
- 依赖可以根据要执行的命令的实际需求, 指定很多个
目标(target)：规则中的目标，这个目标和规则中的命令是对应的
- 通过执行规则中的命令，可以生成一个和目标同名的文件
- 规则中可以有多个命令, 因此可以通过这多条命令来生成多个目标, 所有目标也可以有很多个
- 通过执行规则中的命令，可以只执行一个动作，不生成任何文件，这样的目标被称为伪目标

3.2、工作原理

在此主要为大家剖析一下通过提供的 makefile 文件，构建工具 make 什么时候编译项目中的所有文件, 什么时候只选择更新项目中的某几个文件。另外再研究一下如果makefile里边有多个规则它们之间是如何配合工作的，我们基于下边的例子，依次进行讲解。

make 命令执行的时候会根据文件的时间戳判定是否执行makefile文件中相关规则中的命令。

目标是通过依赖生成的，因此正常情况下：目标时间戳 > 所有依赖的时间戳, 如果执行 make 命令的时候检测到规则中的目标和依赖满足这个条件, 那么规则中的命令就不会被执行。
当依赖文件被更新了, 文件时间戳也会随之被更新, 这时候 目标时间戳 < 某些依赖的时间戳, 在这种情况下目标文件会通过规则中的命令被重新生成。
如果规则中的目标对应的文件根本就不存在，那么规则中的命令肯定会被执行。

3.3、自动推导

make 是一个功能强大的构建工具，虽然make需要根据 makefile 中指定的规则来完成源文件的编译。作为小白的我们编写makefile的时候难免写的不是那么严谨从而漏写一些构建规则，但是我们会发现程序还是会被编译成功。这是因为 make 有自动推导的能力，不会完全依赖 makefile。

比如: 使用命令 make 编译扩展名为.c 的 C 语言文件的时候，源文件的编译规则不用明确给出。这是因为 make 进行编译的时候会使用一个默认的编译规则，按照默认规则完成对.c文件的编译，生成对应的.o 文件。它使用命令cc -c来编译.c 源文件。在 Makefile 中只要给出需要构建的目标文件名（一个.o 文件），make 会自动为这个.o 文件寻找合适的依赖文件（对应的.c 文件），并且使用默认的命令来构建这个目标文件。

假设本地项目目录中有以下几个源文件:

$ tree
.
├── add.c
├── div.c
├── head.h
├── main.c
├── makefile
├── mult.c
└── sub.c

目录中 makefile 文件内容如下

calc:add.o  div.o  main.o  mult.o  sub.o
       gcc  add.o  div.o  main.o  mult.o  sub.o -o calc

通过make构建项目:

$ make
cc    -c -o add.o add.c
cc    -c -o div.o div.c
cc    -c -o main.o main.c
cc    -c -o mult.o mult.c
cc    -c -o sub.o sub.c
gcc  add.o  div.o  main.o  mult.o  sub.o -o calc

我们可以发现上边的 makefile 文件中只有一条规则, 依赖中所有的 .o文件在本地项目目录中是不存在的, 并且也没有其他的规则用来生成这些依赖文件, 这时候 make 会使用内部默认的构造规则先将这些依赖文件生成出来, 然后在执行规则中的命令, 最后生成目标文件 calc。

3.4、变量

使用 Makefile 进行规则定义的时候，为了写起来更加灵活，我们可以在里边使用变量。makefile中的变量分为三种：自定义变量，预定义变量和自动变量。

自定义变量用 Makefile 进行规则定义的时候，用户可以定义自己的变量，称为用户自定义变量。makefile 中的变量是没有类型的，直接创建变量然后给其赋值就可以了。

变量名=变量值

预定义变量 在 Makefile 中有一些已经定义的变量，用户可以直接使用这些变量，不用进行定义。在进行编译的时候，某些条件下 Makefile 会使用这些预定义变量的值进行编译。这些预定义变量的名字一般都是大写的，经常采用的预定义变量如下表所示：

变量名	含义	默认值
AR	生成静态库库文件的程序名称	ar
AS	汇编编译器的名称	as
CC	C 语言编译器的名称	cc
CPP	C 语言预编译器的名称	$(CC) -E
CXX	C++语言编译器的名称	g++
FC	FORTRAN 语言编译器的名称	f77
RM	删除文件程序的名称	rm -f
ARFLAGS	生成静态库库文件程序的选项	无默认值
ASFLAGS	汇编语言编译器的编译选项	无默认值
CFLAGS	C 语言编译器的编译选项	无默认值
CPPFLAGS	C 语言预编译的编译选项	无默认值
CXXFLAGS	C++语言编译器的编译选项	无默认值
FFLAGS	FORTRAN 语言编译器的编译选项	无默认

自动变量：Makefile 中的变量除了用户自定义变量和预定义变量外，还有一类自动变量。Makefile 中的规则语句中经常会出现目标文件和依赖文件，自动变量用来代表这些规则中的目标文件和依赖文件，并且它们只能在规则的命令中使用。

下表中是一些常见的自动变量。

变量	含义
$*	表示目标文件的名称，不包含目标文件的扩展名
$+	表示所有的依赖文件，这些依赖文件之间以空格分开，按照出现的先后为顺序，其中可能包含重复的依赖文件
$<	表示依赖项中第一个依赖文件的名称
$?	依赖项中，所有比目标文件时间戳晚的依赖文件，依赖文件之间以空格分开
$@	表示目标文件的名称，包含文件扩展名
$^	依赖项中，所有不重复的依赖文件，这些文件之间以空格分开

3.5、模式匹配

在介绍概念之前, 先读一下下面的这个 makefile 文件:

calc:add.o  div.o  main.o  mult.o  sub.o
        gcc  add.o  div.o  main.o  mult.o  sub.o -o calc

add.o:add.c
        gcc add.c -c

div.o:div.c
        gcc div.c -c

main.o:main.c
        gcc main.c -c

sub.o:sub.c
        gcc sub.c -c

mult.o:mult.c
        gcc mult.c -c

在阅读过程中能够发现从第二个规则开始到第六个规则做的是相同的事情, 但是由于文件名不同不得不在文件中写出多个规则，这就让 makefile 文件看起来非常的冗余，我们可以将这一系列的相同操作整理成一个模板，所有类似的操作都通过模板去匹配 makefile 会因此而精简不少，只是可读性会有所下降。

这个规则模板可以写成下边的样子，这种操作就称之为模式匹配。

%.o:%.c	gcc $< -c

3.6、函数

makefile中有很多函数并且所有的函数都是有返回值的。makefile中函数的格式和C/C++中函数也不同，其写法是这样的： $(函数名参数1, 参数2, 参数3, ...)，主要目的是让我们能够快速方便的得到函数的返回值。

这里为大家介绍两个 makefile 中使用频率比较高的函数：wildcard和patsubst。

wildcard

这个函数的主要作用是获取指定目录下指定类型的文件名，其返回值是以空格分割的、指定目录下的所有符合条件的文件名列表。函数原型如下：

$(wildcard PATTERN...)
    参数:    指定某个目录, 搜索这个路径下指定类型的文件，比如： *.c

参数功能:
- PATTERN 指的是某个或多个目录下的对应的某种类型的文件, 比如当前目录下的.c文件可以写成 *.c
- 可以指定多个目录，每个路径之间使用空格间隔
返回值：
- 得到的若干个文件的文件列表，文件名之间使用空格间隔
- 示例：$(wildcard *.c ./sub/*.c)
  - 返回值格式: a.c b.c c.c d.c e.c f.c ./sub/aa.c ./sub/bb.c

patsubst

这个函数的功能是按照指定的模式替换指定的文件名的后缀, 函数原型如下:

$(patsubst <pattern>,<replacement>,<text>)

参数功能:
- pattern: 这是一个模式字符串, 需要指定出要被替换的文件名中的后缀是什么
  - 文件名和路径不需要关心, 因此使用 % 表示即可 [通配符是 %]
  - 在通配符后边指定出要被替换的后缀, 比如: %.c, 意味着 .c的后缀要被替换掉
- replacement: 这是一个模式字符串, 指定参数pattern中的后缀最终要被替换为什么
  - 还是使用 % 来表示参数pattern 中文件的路径和名字
  - 在通配符 % 后边指定出新的后缀名, 比如: %.o 这表示原来的后缀被替换为 .o
- text: 该参数中存储这要被替换的原始数据
- 返回值:
  - 函数返回被替换过后的字符串。

Reference：

【1】Makefile | 爱编程的大丙 (subingwen.cn)

PyQT 软件安装

Fri, 12 Sep 2025 00:00:00 GMT

PyQT 软件安装

一、环境配置

1、基础环境

$ pip install pyqt6

2、Qt creater

https://mirrors.tuna.tsinghua.edu.cn/

2、搜索QT

3、打开[archive]

3、打开[online_installers]

4、选择最新版

5、选择linux下的最新版

6、下载安装

Reference

【1】Qt安装教程以及QT Creater，同时使用清华源镜像，解决安装过慢的问题_qt清华镜像-CSDN博客

ASCII输出光标和颜色

Fri, 12 Sep 2025 00:00:00 GMT

ASCII输出光标和颜色

ASCII 控制字符 - "\033"

ASCII控制字符的编号范围是0-31和127（0x00-0x1F和0x7F），共33个字符。

输出到控制台时，可以利用控制字符来控制输出文本的显示效果。

控制字符可以用8进制或16进制表示，比如："\033", "\0x1b", "\x1b"均表示同一个控制字符，含义是ESC

ESC后面跟一个格式字符串，用来设置颜色或控制光标

格式	含义
\033[0m	关闭所有属性
\033[1m	设置高亮度
\033[4m	下划线
\033[5m	闪烁
\033[7m	反显
\033[8m	消隐
\033[30~37m	设置前景色
\033[40~47;m	设置背景色
\033[nA	光标上移n行
\033[nB	光标下移n行
\033[nC	光标右移n行
\033[nD	光标左移n行
\033[y;xH	设置光标位置 printf("\033[%d;%dH", (x), (y))
\033[2J	清屏
\033[K	清除从光标到行尾的内容
\033[s	保存光标位置
\033[u	恢复光标位置
\033[?25l	隐藏光标
\033[?25h	显示光标

显示光标

前景色和背景色对应的数字

颜色	背景色	背景色加亮	前景色	前景色加亮
黑	40	100	30	90
红	41	101	31	91
绿	42	102	32	92
黄	43	103	33	93
蓝	44	104	34	94
紫	45	105	35	95
靛蓝	46	106	36	96
白	47	107	37	97

使用echo命令进行测试

可以使用echo命令对格式字符串进行测试

例如:

echo -e "\033[41;36m 一段文字 \033[0m"

这里先把控制台的背景色设置为红色（41），文字的颜色设置为靛蓝色（36），打印一段文字后，关闭了所有设置（还原到默认状态下）

测试不同的前景色

C语言控制颜色和输出

#include <stdio.h>
#include <unistd.h>
// 清除屏幕
#define CLEAR() printf("\033[2J")
// 上移光标
#define MOVEUP(x) printf("\033[%dA", (x))
// 下移光标
#define MOVEDOWN(x) printf("\033[%dB", (x))
// 左移光标
#define MOVELEFT(y) printf("\033[%dD", (y))
// 右移光标
#define MOVERIGHT(y) printf("\033[%dC",(y))
// 定位光标
#define MOVETO(x,y) printf("\033[%d;%dH", (x), (y))
// 光标复位
#define RESET_CURSOR() printf("\033[H")
// 隐藏光标
#define HIDE_CURSOR() printf("\033[?25l")
// 显示光标
#define SHOW_CURSOR() printf("\033[?25h")
//反显
#define HIGHT_LIGHT() printf("\033[7m")
#define UN_HIGHT_LIGHT() printf("\033[27m")
int main(int argc,char **argv)
{
    // 颜色
    printf("\033[31mThe color,%s!\033[1m\n","haha");
    printf("\033[31mThe color,%s!\033[4m\n","haha");
    printf("\033[31mThe color,%s!\033[5m\n","haha");
    printf("\033[31mThe color,%s!\033[7m\n","haha");
    printf("\033[31mThe color,%s!\033[8m\n","haha");
    printf("\033[31mThe color,%s!\033[0m\n","haha");
    printf("\033[47;31mThe color,%s!\033[0m\n","haha");
    printf("\033[47mThe color,%s!\033[0m\n","haha");
    // 光标
    sleep(2);
    printf("\033[47m%s!\033[5A\n","up 5");
    sleep(2);
    printf("\033[47m%s!\033[9B\n","down 9");
    sleep(2);
    printf("\033[47m%s!\033[19C\n","right 19");
    printf("right19");
    sleep(2);
    printf("\033[47m%s!\033[10D\n","left 10");
    printf("left 10");
    sleep(2);
    printf("\033[47m%s!\033[50;20H\n","move to y:50,x 20");
    printf("y50 x 20");
    sleep(2);
    printf("\033[47m%s!\033[?25l\n","hide cursor");
    sleep(2);
    printf("\033[47m%s!\033[?25h\n","sow cursor");
    sleep(2);
    printf("\033[47m%s!\033[2J\n","clear scleen");
    sleep(2);

    return 0;
}

Reference

【1】https://www.cnblogs.com/sunhaixian/p/16528087.html

【2】https://blog.csdn.net/kevinshq/article/details/8179252

导出依赖包

Sat, 12 Jul 2025 00:00:00 GMT

导出依赖包

1、导出虚拟环境中的包

导出pip已经安装的所有包

$ pip freeze > requirements.txt

上面这种方式只适合在虚拟环境中导出虚拟环境中的包，如果不是在虚拟环境下就会导出全局环境的python的环境包

2、导出项目依赖的包

当我们只想导出我们创建的项目的依赖包，而我们的项目又不在虚拟环境中，这样就会导出多余的包，

要想在全局环境中导出我们项目的依赖包，可以利用python包pipreqs

$ pip install pipreqs

进入到项目所在目录，在执行下面的命令

$ pipreqs . --encoding=utf8 --force

# “.” 指的是将导出依赖包的文件放在当前目录下

# “--encoding=utf8” 指的是存放文件的编码为utf-8,否则会报错

# “--force” --force 强制执行，当生成目录下的requirements.txt存在时强制覆盖

安装基础地震常用软件脚本

Thu, 12 Jun 2025 00:00:00 GMT

安装基础地震常用软件脚本

sudo apt update
sudo apt upgrade
mkdir -p ~/miniconda3
wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh -O ~/miniconda3/miniconda.sh
bash ~/miniconda3/miniconda.sh -b -u -p ~/miniconda3
rm ~/miniconda3/miniconda.sh
source ~/miniconda3/bin/activate
conda init --all
conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main/
conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free/
conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/conda-forge/
conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/msys2/
conda config --set show_channel_urls yes
pip install pip -U
pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple
pip install numpy scipy pandas matplotlib seaborn
pip install numpy pandas matplotlib
pip install scipy
pip install tqdm
pip install jupyter
pip install matplotlib
pip install scons
sudo apt install python3 python-is-python3 python3-dev python-dev-is-python3 python3-pip python3-numpy libxaw7-dev freeglut3-dev libnetpbm10-dev libgd-dev libplplot-dev libcairo2-dev libjpeg-dev swig g++ gfortran libopenmpi-dev libfftw3-dev libsuitesparse-dev git
sudo apt update
sudo apt install -y build-essential gfortran  libx11-dev libxt-dev libxaw7-dev     xorg-dev libmotif-dev libxmu-dev libxext-dev libpng-dev libjpeg-dev libgif-dev     libtiff-dev libfftw3-dev libblas-dev liblapack-dev ghostscript gv
sudo apt install x11-apps
sudo apt install libtirpc-dev
sudo apt-get install imagemagick

安装seismic Unix

cd ~/Software/seismic_unix
tar -xvf cwp_su_all_44R28.tgz
echo '# Seismic Unix
export CWPROOT=~/Software/seismic_unix
export PATH=$PATH:$CWPROOT/bin' >> ~/.bashrc
~/.bashrc
cp ~/Software/seismic_unix/Makefile.config ~/Software/seismic_unix/src/Makefile.config
cd ~/Software/seismic_unix/src
make install
make xtinstall
make finstall
make utils
make xminstall
make mglinstall
suplane |suximage

#=======================================================================
#                 Makefile.config for Gnu/Linux
#=======================================================================
#-----------------------------------------------------------------------
# pick up the Make rules (Gnu make required)
#-----------------------------------------------------------------------

include $(CWPROOT)/src/Rules/gnumake.rules
include $(CWPROOT)/src/Rules/abbrev.rules
include $(CWPROOT)/src/Rules/cflags.rules
include $(CWPROOT)/src/Rules/suffix.rules
include $(CWPROOT)/src/Rules/misc.rules
include $(CWPROOT)/src/Rules/opengl.rules

#-----------------------------------------------------------------------
#                      CWP feature options
#-----------------------------------------------------------------------
#
# LINEHDRFLAG=SU_LINEHEADER  - adds 3200 byte text & 400 byte SEG-Y
#                              style line headers to output. CWP/SU
#                              always reads either format unless SUXDR
#                              has been selected.
#
# XDRFLAG=-DSUXDR            - forces all SU data to be big endian
#                              independent of processor architecture
#
# LARGE_FILE_FLAG            - controls access to files > 2 GB on
#                              some systems.
#
# -DSLTSU_SEGY_H             - if defined selects SLT/SU trace header
#                              layout so both packages are compatible
#-----------------------------------------------------------------------

LINEHDRFLAG =

# if the include files  are under  /usr/include/rpc use this for XDR
# whether or not you had to install libtrpc.a
# make sure
XDRFLAG =  -DSUXDR
XDRLFLAGS =
XDRIFLAGS =

# else if you had to install libtirpc and the rpc include files are under
# /usr/include/tirpc/rpc or if you get an error about <types.h> not found,
#  and you want to use XDR, then make sure the next three lines are uncommented
XDRFLAG = -DSUXDR -DSUTIRPC
XDRIFLAGS = -I/usr/include/tirpc/rpc -I/usr/include/tirpc
XDRLFLAGS = -ltirpc

# else if you do not want to use XDR, uncomment the next three lines
#XDRFLAG =
#XDRLFLAGS =
#XDRIFLAGS =


# Most systems are LITTLE_ENDIAN these days
ENDIANFLAG = -DCWP_LITTLE_ENDIAN
LARGE_FILE_FLAG = -D_FILE_OFFSET_BITS=64 -D_LARGEFILE64_SOURCE

CWP_FLAGS = $(LARGE_FILE_FLAG) $(ENDIANFLAG) $(XDRFLAG) $(XDRIFLAGS) $(LINEHDRFLAG)

#-----------------------------------------------------------------------
# system stuff
#-----------------------------------------------------------------------

SHELL = /bin/sh
ROOT = $(CWPROOT)

LN = ln # this needs to be changed to cp for FAT32 filesystems
AR = ar
ARFLAGS = rv
RANLIB = ranlib
RANFLAGS =
ICHMODLINE = chmod 644 $@
MCHMODLINE = chmod 755 $@

POSTLFLAGS = $(XDRLFLAGS)

#-----------------------------------------------------------------------
# use both X11 path conventions
#-----------------------------------------------------------------------

IX11 = /usr/X11/include
LX11 = /usr/X11/lib
IMOTIF = /usr/X11R6/include
LMOTIF = /usr/X11R6/lib

LD_LIBRARY_PATH += $(CWPROOT)/lib:${LX11}:${LMOTIF}

#-----------------------------------------------------------------------
# Sun/Oracle compilers  comment out the Gnu compiler section to use
#-----------------------------------------------------------------------

CPP = cpp

CC = cc
#OPTC = -g -Xc  -xc99
OPTC = -O -Xc  -xc99
#CFLAGS = -I$I $(OPTC) $(CWP_FLAGS) -D_BSD_SOURCE -D_POSIX_SOURCE
CFLAGS = -I$I $(OPTC) $(CWP_FLAGS) -D_DEFAULT_SOURCE -D_POSIX_SOURCE

FC = f90 -f77
OPTF = -g
FFLAGS =

C++FLAGS = -I$I $(OPTC) $(CWP_FLAGS)

#-----------------------------------------------------------------------
# Gnu compilers by default just because they are the most common
#-----------------------------------------------------------------------

CPP = cpp

#CC = clang
CC = gcc
#OPTC = -g  -std=c99 -Wall -pedantic -Wno-long-long
OPTC = -O  -std=c99 -Wall -pedantic -Wno-long-long
#CFLAGS = -I$I $(OPTC) $(CWP_FLAGS) -D_BSD_SOURCE -D_POSIX_SOURCE
CFLAGS = -I$I $(OPTC) $(CWP_FLAGS) -D_DEFAULT_SOURCE -D_POSIX_SOURCE

FC = gfortran
FOPTS = -g
FFLAGS = $(FOPTS) -ffixed-line-length-none

C++FLAGS = -I$I $(OPTC) $(CWP_FLAGS)

安装Madagascar

sudo apt install unzip
sudo apt install -y libavcodec-dev
cd ~/Software/madagascar
unzip src-master.zip
cd src-master
./configure --prefix=~/Software/madagascar/src-master API=c++,fortran-90
scons
make
make install
echo  '# madagascar
source ~/Software/madagascar/src-master/env.sh' >>~/.bashrc
~/.bashrc

hugFace 下载

Mon, 12 May 2025 00:00:00 GMT

hugFace 下载

安装依赖

pip install -U huggingface_hub
sudo apt install aria2 -y
wget https://hf-mirror.com/hfd/hfd.sh
chmod a+x hfd.sh

2. 设置环境变量

Linux

export HF_ENDPOINT=https://hf-mirror.com

Windows Powershell

$env:HF_ENDPOINT = "https://hf-mirror.com"

3、下载实例

./hfd.sh subsurfacegen/field-scale-dataset \
    --dataset \
    --local-dir ./subsurfacegen \
    --include "models/*" "slices/*"

hfd的多线程下载文件

#!/usr/bin/env bash
RED='\033[0;31m'; GREEN='\033[0;32m'; YELLOW='\033[1;33m'; DIM='\033[2m'; BOLD='\033[1m'; NC='\033[0m' # No Color

trap 'printf "\n%bInterrupted. Re-run to resume.%b\n" "$YELLOW" "$NC"; exit 130' INT

# Format a byte count as a human-readable string (decimal units, matching the HF UI).
human() {
    awk -v b="${1:-0}" 'BEGIN{u="B KB MB GB TB PB";n=split(u,a," ");i=1;
        while(b>=1000&&i<n){b/=1000;i++} printf (i==1?"%d%s":"%.2f%s"),b,a[i]}'
}

display_help() {
    cat << EOF
Usage:
  hfd <REPO_ID> [--include include_pattern1 include_pattern2 ...] [--exclude exclude_pattern1 exclude_pattern2 ...] [--hf_username username] [--hf_token token] [--tool aria2c|wget] [-x threads] [-j jobs] [--dataset] [--local-dir path] [--revision rev]

Description:
  Downloads a model or dataset from Hugging Face using the provided repo ID.

Arguments:
  REPO_ID         The Hugging Face repo ID (Required)
                  Format: 'org_name/repo_name' or legacy format (e.g., gpt2)
Options:
  include/exclude_pattern The patterns to match against file path, supports wildcard characters.
                  e.g., '--exclude *.safetensor *.md', '--include vae/*'.
  --include       (Optional) Patterns to include files for downloading (supports multiple patterns).
  --exclude       (Optional) Patterns to exclude files from downloading (supports multiple patterns).
  --hf_username   (Optional) Hugging Face username for authentication (not email).
  --hf_token      (Optional) Hugging Face token for authentication.
  --tool          (Optional) Download tool to use: aria2c (default) or wget.
  -x              (Optional) Number of download threads for aria2c (default: 4).
  -j              (Optional) Number of concurrent downloads for aria2c (default: 5).
  --dataset       (Optional) Flag to indicate downloading a dataset.
  --local-dir     (Optional) Directory path to store the downloaded data.
                             Defaults to the current directory with a subdirectory named 'repo_name'
                             if REPO_ID is composed of 'org_name/repo_name'.
  --revision      (Optional) Model/Dataset revision to download (default: main).

Example:
  hfd gpt2
  hfd bigscience/bloom-560m --exclude *.safetensors
  hfd meta-llama/Llama-2-7b --hf_username myuser --hf_token mytoken -x 4
  hfd lavita/medical-qa-shared-task-v1-toy --dataset
  hfd bartowski/Phi-3.5-mini-instruct-exl2 --revision 5_0
EOF
    exit 1
}

[[ -z "$1" || "$1" =~ ^-h || "$1" =~ ^--help ]] && display_help

REPO_ID=$1
shift

# Default values
TOOL="aria2c"
THREADS=4
CONCURRENT=5
HF_ENDPOINT=${HF_ENDPOINT:-"https://huggingface.co"}
INCLUDE_PATTERNS=()
EXCLUDE_PATTERNS=()
REVISION="main"

validate_number() {
    [[ "$2" =~ ^[1-9][0-9]*$ && "$2" -le "$3" ]] || { printf "%b[Error] %s must be 1-%s%b\n" "$RED" "$1" "$3" "$NC"; exit 1; }
}

# Argument parsing
while [[ $# -gt 0 ]]; do
    case $1 in
        --include) shift; while [[ $# -gt 0 && ! ($1 =~ ^--) && ! ($1 =~ ^-[^-]) ]]; do INCLUDE_PATTERNS+=("$1"); shift; done ;;
        --exclude) shift; while [[ $# -gt 0 && ! ($1 =~ ^--) && ! ($1 =~ ^-[^-]) ]]; do EXCLUDE_PATTERNS+=("$1"); shift; done ;;
        --hf_username) HF_USERNAME="$2"; shift 2 ;;
        --hf_token) HF_TOKEN="$2"; shift 2 ;;
        --tool)
            [[ "$2" == aria2c || "$2" == wget ]] || { printf "%b[Error] Invalid tool. Use 'aria2c' or 'wget'.%b\n" "$RED" "$NC"; exit 1; }
            TOOL="$2"; shift 2 ;;
        -x) validate_number "threads (-x)" "$2" 10; THREADS="$2"; shift 2 ;;
        -j) validate_number "concurrent downloads (-j)" "$2" 10; CONCURRENT="$2"; shift 2 ;;
        --dataset) DATASET=1; shift ;;
        --local-dir) LOCAL_DIR="$2"; shift 2 ;;
        --revision) REVISION="$2"; shift 2 ;;
        *) display_help ;;
    esac
done

# A fingerprint of the options that affect the file list; a change forces regeneration.
generate_command_string() {
    printf 'REPO_ID=%s TOOL=%s INCLUDE=%s EXCLUDE=%s DATASET=%s HF_USERNAME=%s HF_TOKEN=%s HF_ENDPOINT=%s REVISION=%s' \
        "$REPO_ID" "$TOOL" "${INCLUDE_PATTERNS[*]}" "${EXCLUDE_PATTERNS[*]}" "${DATASET:-0}" \
        "${HF_USERNAME:-}" "${HF_TOKEN:-}" "${HF_ENDPOINT:-}" "$REVISION"
}

check_command() {
    if ! command -v "$1" &>/dev/null; then
        printf "%b%s is not installed. Please install it first.%b\n" "$RED" "$1" "$NC"
        exit 1
    fi
}

check_command curl; check_command "$TOOL"

LOCAL_DIR="${LOCAL_DIR:-${REPO_ID#*/}}"
mkdir -p "$LOCAL_DIR/.hfd"

REPO_API_PATH="models/$REPO_ID"; DOWNLOAD_API_PATH="$REPO_ID"
[[ "$DATASET" == 1 ]] && { REPO_API_PATH="datasets/$REPO_ID"; DOWNLOAD_API_PATH=$REPO_API_PATH; }

# wget --cut-dirs strips "<download_api_path>/resolve/<revision>/"; a fixed value wrongly
# assumes the org/name form and eats a directory level for legacy (single-name) repo ids.
CUT_DIRS=$(( $(printf '%s' "$DOWNLOAD_API_PATH" | tr -cd '/' | wc -c) + 3 ))

# Metadata API URL (used for the gated/auth check); append revision when not main.
METADATA_API_PATH="$REPO_API_PATH"
[[ "$REVISION" != "main" ]] && METADATA_API_PATH="$METADATA_API_PATH/revision/$REVISION"
API_URL="$HF_ENDPOINT/api/$METADATA_API_PATH?blobs=true"

METADATA_FILE="$LOCAL_DIR/.hfd/repo_metadata.json"

fetch_and_save_metadata() {
    status_code=$(curl -L -s -w "%{http_code}" -o "$METADATA_FILE" ${HF_TOKEN:+-H "Authorization: Bearer $HF_TOKEN"} "$API_URL")
    RESPONSE=$(cat "$METADATA_FILE")
    if [ "$status_code" -eq 200 ]; then
        printf "%s\n" "$RESPONSE"
    else
        printf "%b[Error] Failed to fetch metadata from %s. HTTP status code: %s.%b\n%s\n" "$RED" "$API_URL" "$status_code" "$NC" "$RESPONSE" >&2
        rm -f "$METADATA_FILE"
        exit 1
    fi
}

# Exit early if the repo is gated/private but no credentials were supplied.
check_authentication() {
    local gated
    if command -v jq &>/dev/null; then
        gated=$(printf '%s' "$1" | jq -r '.gated // false')
    else
        printf '%s' "$1" | grep -q '"gated":[^f]' && gated=true || gated=false
    fi
    if [[ "$gated" != "false" && ( -z "$HF_TOKEN" || -z "$HF_USERNAME" ) ]]; then
        printf "%bThe repository requires authentication, but --hf_username and --hf_token is not passed. Please get token from https://huggingface.co/settings/tokens.\nExiting.\n%b" "$RED" "$NC"
        exit 1
    fi
}

printf "%b%s%b (%s)\n" "$BOLD" "$REPO_ID" "$NC" "$REVISION"
if [[ ! -f "$METADATA_FILE" ]]; then
    printf "%bFetching metadata...%b\n" "$DIM" "$NC"
    RESPONSE=$(fetch_and_save_metadata) || exit 1
else
    RESPONSE=$(cat "$METADATA_FILE")
fi
check_authentication "$RESPONSE"

# Total bytes of the revision (cheap, branch-specific); empty if the endpoint lacks this API.
fetch_treesize() {
    local json
    json=$(curl -sSL ${HF_TOKEN:+-H "Authorization: Bearer $HF_TOKEN"} "$HF_ENDPOINT/api/$REPO_API_PATH/treesize/$REVISION") || return
    if command -v jq &>/dev/null; then
        printf '%s' "$json" | jq -r '.size // empty' 2>/dev/null
    else
        printf '%s' "$json" | grep -o '"size":[0-9]*' | head -1 | grep -o '[0-9]*'
    fi
}
# Reuse the cached list only if the command is unchanged AND the manifest is intact (its line
# count equals repo_info's total). An interrupted/failed walk leaves no repo_info, so it re-lists.
should_regenerate_filelist() {
    local cmd="$LOCAL_DIR/.hfd/last_download_command" mf="$LOCAL_DIR/.hfd/manifest" info="$LOCAL_DIR/.hfd/repo_info"
    [[ -f "$mf" && -f "$info" && "$(generate_command_string)" == "$(cat "$cmd" 2>/dev/null)" \
       && "$(wc -l < "$mf")" == "$(cut -d' ' -f1 "$info" 2>/dev/null)" ]] && return 1
    return 0
}

fileslist_file=".hfd/${TOOL}_urls.txt"

# Convert a list of wildcard patterns into a single alternation regex.
patterns_to_regex() {
    (($#)) || return 0
    printf '%s\n' "$@" | sed 's/\./\\./g; s/\*/.*/g' | paste -sd '|' -
}

# Emit "size<TAB>path" for every file in a tree page (jq, or a grep/awk fallback).
emit_page_files() {
    if command -v jq &>/dev/null; then
        jq -r '.[] | select(.type=="file") | "\(.size)\t\(.path)"' "$1"
    else
        # Strip the nested lfs{} object (it has its own "size") so type/size/path align per entry.
        sed 's/"lfs":{[^}]*}//g' "$1" \
            | grep -oE '"type":"[^"]*"|"size":[0-9]+|"path":"[^"]*"' \
            | sed 's/"type":"//; s/"size"://; s/"path":"//; s/"$//' \
            | awk 'NR%3==1{t=$0} NR%3==2{s=$0} NR%3==0{if(t=="file")print s"\t"$0}'
    fi
}

# Emit "size<TAB>path" for every file from the cached metadata siblings[] (needs jq).
emit_siblings() {
    jq -r '(.siblings // [])[] | "\(.size // 0)\t\(.rfilename)"' "$METADATA_FILE"
}

# True when siblings[] is the complete list: its sizes sum to treesize (so it wasn't truncated, as
# it is for very large repos). Lets us skip the slow tree walk for typical repos via one API call.
siblings_complete() {
    command -v jq &>/dev/null && [[ "$REPO_SIZE" =~ ^[0-9]+$ ]] || return 1
    local n s
    read -r n s < <(jq -r '(.siblings // []) as $s | "\($s|length) \([$s[].size // 0]|add // 0)"' "$METADATA_FILE" 2>/dev/null)
    (( ${n:-0} > 0 )) && [[ "${s:-0}" == "$REPO_SIZE" ]]
}

# Keep only "size<TAB>path" stdin lines matching include/exclude (the *_REGEX globals).
filter_size_path() {
    local size path
    while IFS=$'\t' read -r size path; do
        [[ -z "$path" ]] && continue
        [[ -n "$INCLUDE_REGEX" && ! "$path" =~ $INCLUDE_REGEX ]] && continue
        [[ -n "$EXCLUDE_REGEX" && "$path" =~ $EXCLUDE_REGEX ]] && continue
        printf '%s\t%s\n' "${size:-0}" "$path"
    done
}

# Resumably walk the recursive tree into .hfd/manifest.partial (filtered size<TAB>path). After each
# page, checkpoint .hfd/list_state (fingerprint / entries scanned / next cursor) so an interrupted or
# failed walk continues from there instead of restarting. Progress (entries scanned) goes to stderr.
walk_tree() {
    local state="$LOCAL_DIR/.hfd/list_state" partial="$LOCAL_DIR/.hfd/manifest.partial"
    local page="$LOCAL_DIR/.hfd/tree_page.json" fp url scanned=0 headers n saved_fp=""
    fp=$(generate_command_string)
    [[ -f "$state" && -f "$partial" ]] && { read -r saved_fp; read -r scanned; read -r url; } < "$state"
    if [[ "$saved_fp" != "$fp" ]]; then   # no checkpoint, or it belongs to a different command
        url="$HF_ENDPOINT/api/$REPO_API_PATH/tree/$REVISION?recursive=true&expand=false"
        scanned=0; : > "$partial"
    elif [[ -s "$partial" && -n "$(tail -c1 "$partial")" ]]; then
        sed -i '$d' "$partial"   # drop a torn final line from a kill mid-append (the page re-fetches)
    fi
    while [[ -n "$url" ]]; do
        headers=$(curl -sSL ${HF_TOKEN:+-H "Authorization: Bearer $HF_TOKEN"} -D - -o "$page" "$url") || return 1
        if command -v jq &>/dev/null; then n=$(jq 'length' "$page" 2>/dev/null); else n=$(grep -o '"type":"' "$page" | wc -l); fi
        emit_page_files "$page" | filter_size_path >> "$partial"
        scanned=$(( scanned + ${n:-0} ))
        printf '\r\033[K%bListing files... %d scanned%b' "$DIM" "$scanned" "$NC" >&2
        url=$(printf '%s' "$headers" | tr -d '\r' | grep -i '^link:' \
            | grep -o '<[^>]*>;[[:space:]]*rel="next"' | sed -n 's/^<\([^>]*\)>.*/\1/p')
        printf '%s\n%s\n%s\n' "$fp" "$scanned" "$url" > "$state"   # checkpoint after the page is in
    done
    return 0
}

# Dedup .hfd/manifest.partial by path (a resumed walk may re-list its boundary page) into the final
# manifest, and write "<count> <bytes>" totals to filelist_stats.
finalize_filelist() {
    local mf="$LOCAL_DIR/.hfd/manifest"
    : > "$mf"
    awk -F'\t' -v mf="$mf" '!seen[$2]++ { print >> mf; n++; s+=$1 } END { print (n+0)" "(s+0) }' \
        "$LOCAL_DIR/.hfd/manifest.partial" > "$LOCAL_DIR/.hfd/filelist_stats"
}

# Build tool input from the manifest; set NEED_COUNT (files still to fetch). One find pass diffs
# the tree, keeping files missing or the wrong size (.aria2 sidecar = in-progress, kept): cheap
# for huge repos, correct after a manual delete. Run from the local dir (manifest paths relative).
build_download_list() {
    local needed=.hfd/needed size path dir cur
    if [[ ! -s .hfd/manifest ]]; then NEED_COUNT=0; : > "$fileslist_file"; return; fi
    awk -F'\t' '
        FNR==NR { want[$2]=$1; ord[++n]=$2; next }
        { p=$2; sub(/^\.\//,"",p);
          if (p ~ /\.aria2$/) { sub(/\.aria2$/,"",p); part[p]=1 } else have[p]=$1 }
        END { for (i=1;i<=n;i++) { q=ord[i];
                if ((q in have) && have[q]==want[q] && !(q in part)) continue;
                print want[q] "\t" q } }
    ' .hfd/manifest <(find . -type f ! -path './.hfd/*' -printf '%s\t%p\n' 2>/dev/null) > "$needed"
    NEED_COUNT=$(wc -l < "$needed")
    # Per needed file: drop a wrong-size copy -c/--continue can't fix in place (aria2c with no
    # .aria2 control file, or a wget file larger than expected) for a fresh refetch; emit the record.
    while IFS=$'\t' read -r size path; do
        [[ -z "$path" ]] && continue
        if [[ "$TOOL" == "aria2c" ]]; then
            [[ -e "$path" && ! -e "$path.aria2" ]] && rm -f "$path"
            dir="${path%/*}"; [[ "$dir" == "$path" ]] && dir=""
            printf '%s/%s/resolve/%s/%s\n dir=%s\n out=%s\n' "$HF_ENDPOINT" "$DOWNLOAD_API_PATH" "$REVISION" "$path" "$dir" "${path##*/}"
            [[ -n "$HF_TOKEN" ]] && printf ' header=Authorization: Bearer %s\n' "$HF_TOKEN"
            printf '\n'
        else
            cur=$(stat -c%s "$path" 2>/dev/null || echo 0); (( cur > size )) && rm -f "$path"
            printf '%s/%s/resolve/%s/%s\n' "$HF_ENDPOINT" "$DOWNLOAD_API_PATH" "$REVISION" "$path"
        fi
    done < "$needed" > "$fileslist_file"
    rm -f "$needed"
}

if should_regenerate_filelist; then
    command -v jq &>/dev/null || printf "%b[Warning] jq not installed, using grep/awk for json parsing (slower). Consider installing jq.%b\n" "$YELLOW" "$NC"

    # Total size up front (before the long walk); label the call so its few-second wait isn't silent.
    printf "%bFetching repository info...%b" "$DIM" "$NC"
    REPO_SIZE=$(fetch_treesize); printf '\r\033[K'
    [[ "$REPO_SIZE" =~ ^[0-9]+$ ]] && printf "%bRepository size: %s%b\n" "$DIM" "$(human "$REPO_SIZE")" "$NC"
    INCLUDE_REGEX=$(patterns_to_regex "${INCLUDE_PATTERNS[@]}")
    EXCLUDE_REGEX=$(patterns_to_regex "${EXCLUDE_PATTERNS[@]}")
    printf "%bListing files...%b" "$DIM" "$NC"
    # Fast path: typical repos return their whole file list in the metadata; only big repos
    # (truncated siblings) need the paginated, resumable tree walk.
    if siblings_complete; then
        rm -f "$LOCAL_DIR/.hfd/list_state"
        emit_siblings | filter_size_path > "$LOCAL_DIR/.hfd/manifest.partial"
        gen_status=${PIPESTATUS[0]}
    else
        walk_tree; gen_status=$?
    fi
    # A failed walk keeps its checkpoint (list_state + manifest.partial), so a re-run resumes.
    (( gen_status == 0 )) || { printf "\n%b[Error] Failed to list repository files. Re-run to resume.%b\n" "$RED" "$NC" >&2; exit 1; }
    finalize_filelist
    read -r TOTAL_FILES SUM_SIZE < "$LOCAL_DIR/.hfd/filelist_stats"
    printf '\r\033[K%bListed %d files (%s)%b\n' "$DIM" "$TOTAL_FILES" "$(human "$SUM_SIZE")" "$NC"
    # Whole-revision total from treesize; the summed filtered size when include/exclude narrows it.
    TOTAL_SIZE=$REPO_SIZE
    [[ -n "$INCLUDE_REGEX$EXCLUDE_REGEX" || ! "$REPO_SIZE" =~ ^[0-9]+$ ]] && TOTAL_SIZE=$SUM_SIZE
    printf '%s %s\n' "$TOTAL_FILES" "$TOTAL_SIZE" > "$LOCAL_DIR/.hfd/repo_info"
    # Fingerprint written last: marks the list complete (an interrupted walk has none, so it re-lists).
    generate_command_string > "$LOCAL_DIR/.hfd/last_download_command"
    rm -f "$LOCAL_DIR/.hfd/manifest.partial" "$LOCAL_DIR/.hfd/list_state" "$LOCAL_DIR/.hfd/tree_page.json"
fi

cd "$LOCAL_DIR" || exit 1

# Render one in-place status line; speed = byte delta since last call (PREV_B/PREV_T).
# Fields are fixed-width so columns don't jitter as values grow a digit; ETA is last.
PREV_B=0; PREV_T=0
render_progress() {
    local now=$1 dfiles=$2 dt sp pct eta e
    dt=$(( SECONDS - PREV_T )); ((dt<1)) && dt=1
    sp=$(( (now - PREV_B) / dt )); ((sp<0)) && sp=0; PREV_B=$now; PREV_T=$SECONDS
    pct=0; ((TOTAL_SIZE>0)) && pct=$(( now * 100 / TOTAL_SIZE )); ((pct>100)) && pct=100
    # ETA only once speed is meaningful; clamp absurd early estimates to keep it tidy.
    eta="--:--"; ((sp>0 && TOTAL_SIZE>now)) && { e=$(( (TOTAL_SIZE-now)/sp )); ((e<360000)) && eta=$(printf '%02d:%02d' $((e/60)) $((e%60))); }
    printf '\r\033[K%b[%3d%%]%b %*d/%d files | %9s/%9s | %9s/s | ETA %s' \
        "$GREEN" "$pct" "$NC" "${#TOTAL_FILES}" "$dfiles" "$TOTAL_FILES" \
        "$(human "$now")" "$(human "$TOTAL_SIZE")" "$(human "$sp")" "$eta"
}

# Progress without scanning finished files: manifest totals + a stat of only in-flight files.
monitor_progress() {
    local interval=$1 base=$1 stop_hint="Stopping download, please wait..."; PREV_T=$SECONDS
    # The main INT trap is deferred until the foreground download returns, so acknowledge
    # Ctrl+C here (fires at once in the subshell) and note the force-stop that already works.
    [[ "$TOOL" == "aria2c" ]] && stop_hint="Stopping download, please wait... (press Ctrl+C again to force stop)"
    trap 'printf "\n%b%s%b\n" "$YELLOW" "$stop_hint" "$NC"; exit 0' INT
    if [[ "$TOOL" == "wget" ]]; then
        # wget downloads in manifest order, so a forward cursor needs to stat only the
        # current file; everything before it is done and counted by its known size.
        local -a MS MP; local s p
        while IFS=$'\t' read -r s p; do MS+=("$s"); MP+=("$p"); done < .hfd/manifest
        local idx=0 done_b=0 cur
        while :; do
            sleep "$interval"
            while (( idx < ${#MP[@]} )); do
                cur=$(stat -c%s "${MP[idx]}" 2>/dev/null) || break
                (( cur >= MS[idx] )) || break
                done_b=$(( done_b + MS[idx] )); idx=$((idx+1))
            done
            cur=0; (( idx < ${#MP[@]} )) && cur=$(stat -c%s "${MP[idx]}" 2>/dev/null || echo 0)
            render_progress $(( done_b + cur )) "$idx"
        done
    else
        # Parallel downloads finish out of order, so a cursor would miss files completing between
        # ticks. Each tick sums block usage (sparse-aware) of the manifest's files only — ignoring
        # stale files left from an earlier version of the repo — minus in-progress (.aria2) ones.
        local now files t0 walk
        while :; do
            sleep "$interval"
            t0=$SECONDS
            read -r now files < <(awk -F'\t' '
                FNR==NR { want[$2]=1; next }
                { p=$2; sub(/^\.\//,"",p)
                  if (p ~ /\.aria2$/) { sub(/\.aria2$/,"",p); if (p in want) a++; next }
                  if (p in want) { b+=$1; d++ } }
                END { print b*512, d-a }
            ' .hfd/manifest <(find . -type f ! -path './.hfd/*' -printf '%b\t%p\n' 2>/dev/null))
            render_progress "$now" "$files"
            # Self-throttle: if the walk took longer than the base interval, sleep that long
            # next time so scanning stays under ~half the wall-clock at any repo size.
            walk=$(( SECONDS - t0 )); interval=$base; (( walk > base )) && interval=$walk
        done
    fi
}

# Totals were persisted at file-list generation; reload for resumed runs.
[[ -f .hfd/repo_info ]] && read -r TOTAL_FILES TOTAL_SIZE < .hfd/repo_info
TOTAL_FILES=${TOTAL_FILES:-0}; TOTAL_SIZE=${TOTAL_SIZE:-0}
FILE_NOUN="files"; ((TOTAL_FILES==1)) && FILE_NOUN="file"

# Diff the local tree against the manifest to find what's missing, then short-circuit if done.
((TOTAL_FILES>50000)) && printf "%bChecking local files...%b\n" "$DIM" "$NC"
build_download_list
if (( NEED_COUNT == 0 )); then
    printf "%bUp to date. %s %s in %s%b\n" "$GREEN" "$TOTAL_FILES" "$FILE_NOUN" "$LOCAL_DIR" "$NC"
    exit 0
fi

# "Resuming" if any data is already on disk (completed files or a partial), else a fresh start.
verb="Downloading"; [[ -n "$(find . -type f ! -path './.hfd/*' -print -quit 2>/dev/null)" ]] && verb="Resuming"
printf "%s %s %s to %s  ·  Ctrl+C to stop, re-run to resume\n" "$verb" "$TOTAL_FILES" "$FILE_NOUN" "$LOCAL_DIR"

# Silence native per-file output (logged to .hfd/download.log) so the monitor owns one
# clean line. Refresh every 1s, backing off for huge repos where the walk gets expensive.
interval=1; ((TOTAL_FILES>50000)) && interval=5
monitor_progress "$interval" &
MON_PID=$!
trap 'kill "$MON_PID" 2>/dev/null' EXIT

if [[ "$TOOL" == "aria2c" ]]; then
    aria2c --quiet=true --log=.hfd/download.log --log-level=error --file-allocation=none \
        -x "$THREADS" -j "$CONCURRENT" -s "$THREADS" -k 1M -c -i "$fileslist_file" >/dev/null
    status=$?
else
    wget -x -nH --cut-dirs="$CUT_DIRS" ${HF_TOKEN:+--header="Authorization: Bearer $HF_TOKEN"} \
        --input-file="$fileslist_file" --continue -nv -o .hfd/download.log
    status=$?
fi

# Clear the live progress line in place; the final status line takes its spot (no blank line).
kill "$MON_PID" 2>/dev/null; wait "$MON_PID" 2>/dev/null; printf '\r\033[K'

if [[ $status -eq 0 ]]; then
    printf "%bDone. %s %s, %s in %s%b\n" "$GREEN" "$TOTAL_FILES" "$FILE_NOUN" "$(human "$TOTAL_SIZE")" "$LOCAL_DIR" "$NC"
else
    printf "%bDownload incomplete. Re-run to resume. Log: %s%b\n" "$RED" "$PWD/.hfd/download.log" "$NC"
    exit 1
fi

参考：https://hf-mirror.com/

CPU高精度计时

Mon, 12 May 2025 00:00:00 GMT

CPU高精度计时

为了在C语言中进行准确计时，可以使用clock()函数，它是C标准库的一部分。clock()函数返回程序开始执行到调用clock()函数时处理器时钟的滴答数。每个时钟滴答的持续时间可以通过CLOCKS_PER_SEC宏来确定，它定义了一秒钟内的时钟滴答数。

以下是一个使用clock()函数进行计时的示例：

复制

#include <stdio.h>
#include <time.h>

int main() {
    clock_t start, end;
    double cpu_time_used;

    start = clock(); // 开始计时

    // 执行一些操作
    for (long i = 0; i < 1000000; ++i) {
        // 这里是一些你想要计时的代码
    }

    end = clock(); // 结束计时

    cpu_time_used = ((double) (end - start)) / CLOCKS_PER_SEC; // 计算使用的CPU时间

    printf("使用的CPU时间: %f 秒\n", cpu_time_used);

    return 0;
}

这个例子中，clock()函数在执行一些操作前后被调用，用来计算这段代码执行所花费的时间。cpu_time_used变量包含了以秒为单位的CPU时间。

如果你需要更高精度的计时，可以使用POSIX标准中的gettimeofday()函数，它在sys/time.h头文件中定义：

复制

#include <stdio.h>
#include <sys/time.h>

int main() {
    struct timeval start, end;
    long mtime, seconds, useconds;

    gettimeofday(&start, NULL); // 开始计时

    // 执行一些操作
    for (long i = 0; i < 1000000; ++i) {
        // 这里是一些你想要计时的代码
    }

    gettimeofday(&end, NULL); // 结束计时

    seconds  = end.tv_sec  - start.tv_sec;
    useconds = end.tv_usec - start.tv_usec;

    mtime = ((seconds) * 1000 + useconds/1000.0) + 0.5;

    printf("使用的CPU时间: %ld 毫秒\n", mtime);

    return 0;
}

在这个例子中，gettimeofday()函数提供了微秒级的精度，可以用于更精确的计时需求。mtime变量包含了以毫秒为单位的执行时间。

Pyside UI设计

Thu, 12 Dec 2024 00:00:00 GMT

Pyside UI设计

一、PySide6将UI文件转换为Python代码

要将.ui文件转换为Python代码，你可以使用pyside6-uic工具，这是PySide6的一部分。以下是如何操作的步骤：

设计UI：使用Qt Designer设计你的界面，并保存为.ui文件。
转换UI文件：在命令行中，使用pyside6-uic工具将.ui文件转换为Python代码。命令如下：
```
pyside6-uic your_file.ui -o your_file.py
```
这个命令会生成一个名为your_file.py的Python文件，其中包含了UI界面的代码。
使用生成的Python代码：在你的应用程序中导入并使用这个生成的Python文件。通常，你需要创建一个继承自QMainWindow或其他适当父类的窗口，并在这个类中加载UI。

下面是一个示例，展示了如何在一个PySide6应用程序中使用转换后的UI代码：

import sys
from PySide6.QtWidgets import QApplication
from your_file import Ui_MainWindow  # 导入转换后的UI代码

class MainWindow(QMainWindow, Ui_MainWindow):
    def __init__(self):
        super().__init__()
        self.setupUi(self)  # 初始化UI界面

def main():
    app = QApplication(sys.argv)
    window = MainWindow()
    window.show()
    sys.exit(app.exec())

if __name__ == '__main__':
    main()

在这个示例中，your_file.py是使用pyside6-uic工具从.ui文件转换得到的。MainWindow类继承了QMainWindow和Ui_MainWindow，其中Ui_MainWindow是转换后的UI类。在MainWindow的构造函数中，我们调用了setupUi方法来初始化UI界面。

PDF批量操作

Fri, 20 Sep 2024 00:00:00 GMT

PDF批量操作

1、批量转换pdf为jpg

    for f in *.pdf; do gs -q -dNOSAFER -r300 -dBATCH -sDEVICE=jpeg -dNOPAUSE -dEPSCrop -sOutputFile=${f%%.*}.jpg $f;  done

2、转换pdf为jpg

    gs -q -dNOSAFER -r300 -dBATCH -sDEVICE=jpeg -dNOPAUSE -dEPSCrop -sOutputFile=xx.jpg 1.pdf

3、批量提取pdf第一页

    for f in `ls`; do pdftk touch $f cat 1 output ./dir/$f; done

4、打包当前文件夹

    zip -r jpg.zip ./

5、拼接pdf

    pdfunite *.pdf all.pdf

当然也可以合并部分，或者按顺序合并pdfunite 1.pdf 2.pdf 3.pdf 4.pdf all-1234.pdf

6、压缩（ghostcript）

    gs -sDEVICE=pdfwrite -dCompatibilityLevel=1.4 -dPDFSETTINGS=/ebook -dNOPAUSE -dBATCH -dQUIET -sOutputFile=output.pdf input.pdf

即大多数情况使用的压缩方式

gs -sDEVICE=pdfwrite -dCompatibilityLevel=1.4 -dDownsampleColorImages=true -dColorImageResolution=130 -dNOPAUSE -dBATCH -sOutputFile=output.pdf input.pdf

不同的压缩模式 -dPDFSETTINGS=/screen,压缩比最大，输出文件最小，质量最低 -dPDFSETTINGS=/ebook,压缩比稍小，输出文件稍大，质量稍高 -dPDFSETTINGS=/prepress,输出文件信息同Acrobat Distiller "Prepress Optimized"设置 -dPDFSETTINGS=/default,缺省的， -dColorImageResolution=130可以设置图像DPI大小

Reference

【1】https://blog.csdn.net/lx_ros/article/details/79887562

混合编译.c/.cpp与.cu文件

Thu, 12 Sep 2024 00:00:00 GMT

混合编译.c/.cpp与.cu文件

项目中用到cuda编程，写了kernel函数，需要nvcc编译器来编译。.c/.cpp的文件，假定用gcc编译。

如何混合编译它们，整体思路是：.cu文件编译出的东西，作为最终编译出的可执行程序的链接依赖。

具体说起来又可以有这几种情况：

分别编译各个文件，最后链接
将CUDA程序编译为静态库
将CUDA程序弄成动态库

其中后两种方式更工程化，基于makefile或CMake会更加方便。

假设手头上的文件为：

test1.cu
test2.c

则具体编译指令、编译脚本如下：

方法1：分别编译各个文件

nvcc -c test1.cu
gcc -c test2.c
gcc -o testc test1.o test2.o -lcudart -L/usr/local/cuda/lib64

方法2: 将cuda程序编译为静态库

nvcc -lib test1.cu -o libtestcu.a
gcc test2.c -ltestcu -L. -lcudart -L/usr/local/cuda/lib64

方法3：将CUDA程序弄成动态库

以makefile为例

all: c

c: libtestcu.so
    gcc test2.c -ltestcu -L. -lcudart -L/usr/local/cuda/lib64 -o testc

libtestcu.so: test.cu
    nvcc -o libtestcu.so -shared -Xcompiler -fPIC test1.cu

方法4：混合编译.c/.cpp与.cu文件

先分别编译，再联合，编译动态库需要把环境变量$LD_LIBRARY_PATH进行修改，否则无法成功

#/bin/bash

CC=/usr/bin/gcc
NVCC=/usr/local/cuda-11.8/bin/nvcc
LIB=/usr/local/cuda-11.8/lib64
INC=/usr/local/cuda-11.8/include
CFLAGS=-I$(INC) -L$(LIB) -lcudart -lstdc++ -lcuda

SRCCS=$(wildcard *.c)   # .c src  file
SRCUS=$(wildcard *.cu)  # .cu src file

# c
OBJCCS_static =$(patsubst %.c, %.o,  $(SRCCS))
OBJCCS_dynamic=$(patsubst %.c, %.os, $(SRCCS))
# cu
OBJCUS_static =$(patsubst %.cu, %.o,  $(SRCUS))
OBJCUS_dynamic=$(patsubst %.cu, %.os, $(SRCUS))

%.os:%.c
    $(CC) -o $@ -c  -O3  -fPIC -shared -Wall $<
%.o:%.c
    $(CC) -o $@ -c  -O3  -Wall -lm $<

%.os:%.cu
    $(NVCC) -o $@ -c -Xcompiler -fPIC --use_fast_math -O3  $<
%.o:%.cu
    $(NVCC) -o $@ -c  -O3 -lcudart --use_fast_math $<

install_dynamic:$(OBJCUS_dynamic) $(OBJCCS_dynamic)
    $(CC)  -o libdlglcu.so  $^  -fPIC -shared  -lm $(CFLAGS)

install_static:$(OBJCUS_static) $(OBJCCS_static)
    ar rc liblglcu.a  $^
    ranlib liblglcu.a

header:
    paste *.h *.cuh -s > lglcu.h

install: install_dynamic install_static header

clean:
    -rm -rf *.o *.os lglcu.h liblglcu.a libdlglcu.so

reference:

【1】https://www.cnblogs.com/zjutzz/p/10272424.html

【2】https://blog.csdn.net/bruce_0712/article/details/78515133

【3】C与CUDA混合编译动态链接文件.so – Chuanqiz’s blog (zangcq.com)

Born modeling in Madagascar

Thu, 12 Sep 2024 00:00:00 GMT

Born modeling in Madagascar

1. 数据准备

from rsf.proj import *

# Prepare source and velocity
#############################

# Source wavelet
Flow('wavelet',None,
     '''
     spike n1=1500 d1=0.001 k1=201 |
     ricker1 frequency=10
     ''')
# Source spectra
Result('spectra','wavelet',
    '''
    spectra |window n1=50 |
    graph title="Source Spectra"
    ''')

# Source location
Flow('source',None,
     '''
     spike n1=501 n2=501 d1=0.01 d2=0.01
     label1=x1 unit1=km label2=x2 unit2=km
     k1=201 k2=251
     ''')

# Background velocity
Flow('v0','source','math output=2.')

# Velocity perturbation
Flow('detv',None,
    '''
    spike n1=501 d1=0.01 o1=0 k1=300,301,302 mag=0.02 |
    spray axis=2 n=501 d=0.01 o=0 |
    costaper nw2=25
    ''')

# True velocity
Flow('vel','v0 detv','add ${SOURCES[1]}')
Result('vel',
    '''
    grey scalebar=y barreverse=y
    color=j bias=2.01 title="Velocity"
    ''')

jupyter 中内联Madagascar绘图

Thu, 12 Sep 2024 00:00:00 GMT

jupyter 中内联Madagascar绘图

1、配置修改

# $RSFROOT/include/Makefile
SConstruct.jupyter: *.scons
    echo "from rsf.proj import *" > $@
    cat $^ >> $@
    echo "" >> $@
    echo "End()" >> $@

## *.vpl->*.eps->*.png
%.png: SConstruct.jupyter
    -rm $@
    scons -Qkf SConstruct.jupyter  $@ || ( \
    scons -Qf SConstruct.jupyter Fig/$*.vpl && \
    vpconvert color=y  Fig/$*.vpl Fig/$*.eps && \
    convert  -background white -flatten Fig/$*.eps $@ )

#%.png: SConstruct.jupyter
#	-rm $@
#	scons -Qf SConstruct.jupyter  $@ || ( \
#	scons -Qf SConstruct.jupyter Fig/$*.vpl && \
#	vpconvert pen=gd fat=3 serifs=n bgcolor=w Fig/$*.vpl $@ )

# /etc/ImageMagick-6/policy.xml
<!--  disable ghostscript format types  -->
<policy xmlns="" domain="coder" rights="read|write" pattern="PS"/>
<policy xmlns="" domain="coder" rights="read|write" pattern="PS2"/>
<policy xmlns="" domain="coder" rights="read|write" pattern="PS3"/>
<policy xmlns="" domain="coder" rights="read|write" pattern="EPS"/>
<policy xmlns="" domain="coder" rights="read|write" pattern="PDF"/>
<policy xmlns="" domain="coder" rights="read|write" pattern="XPS"/>

2、绘图

%%file plot2d.scons
Result('vvvv','test','grey color=j scalebar=y  label1=Depth label2=Distance unit1=m unit2=m title=" " screenratio=0.5')

view('vvvv')

WSL2 卸载安装

Thu, 12 Sep 2024 00:00:00 GMT

WSL2 卸载安装

1、安装

启动虚拟机平台和linux windows.

2、升级WSL内核和启用虚拟机功能

内核地址：https://wslstorestorage.blob.core.windows.net/wslblob/wsl_update_x64.msi

安装 WSL 2 之前，必须启用“虚拟机平台”可选功能。计算机需要虚拟化功能才能使用此功能。以管理员身份打开PowerShell并运行：重启

dism.exe /online /enable-feature /featurename:Microsoft-Windows-Subsystem-Linux /all /norestart
dism.exe /online /enable-feature /featurename:VirtualMachinePlatform /all /norestart
wsl --set-default-version 2

3、导入备份

改为默认用户权限

查看当前用户 ls /home/
尝试切换至用户权限 su 用户名
切换至root权限 sudo su
修改默认配置文件
1. 备份 cp /etc/wsl.conf /etc/wsl.conf.bk
2. 修改 vim /etc/wsl.conf 在最前面增加以下内容
```
[user]
default=用户名
```

Reference

【1】旧版 WSL 的手动安装步骤 | Microsoft Learn

创建一个Linux文件目录结构图

Thu, 12 Sep 2024 00:00:00 GMT

创建一个文件目录结构图

在README文件中创建一个文件目录结构图通常涉及使用代码块来表示文件和文件夹的层次结构。这里有一个步骤指南来创建一个基本的文件目录结构图：

确定结构: 首先，你需要确定你想展示的文件和文件夹的结构。决定哪些目录和文件是重要的，以及它们是如何组织的。
使用缩进: 在README文件中，你可以使用缩进来表示文件和文件夹之间的层次关系。通常，一个缩进可以用一个制表符或者四个空格表示。
使用符号: 人们通常使用一些特殊的符号来表示文件夹和文件。例如，/ 通常用于表示目录，而文件则直接写文件名。你也可以使用其他符号来增强可读性，比如├─, └─, 或 │。

以下是一个简单的文件目录结构图的例子：

project-name/
│
├── dir1/
│   ├── file1.ext
│   └── file2.ext
│
├── dir2/
│   ├── sub-dir1/
│   │   └── file3.ext
│   └── sub-dir2/
│
└── dir3/
    ├── file4.ext
    └── file5.ext

在这个例子中:

project-name 是最顶层的文件夹。
dir1,dir2, dir3 是它下面的子文件夹。
file1.ext, file2.ext 等是文件。
sub-dir1, sub-dir2 是dir2下的子文件夹。

这个结构图可以直接写入Markdown文件中，通常作为代码块来保持格式一致。这种方式简单且直观，可以帮助读者理解项目的组织结构。

自动生成方案

在 Windows(需支持WSL)/MacOS/Linux中，可以使用工具tree来自动生成目录结构。

安装tree

Windows（WSL）/Linux：

sudo apt-get install tree

MacOS：

brew install tree

使用tree自动生成目录结构

进入你需要生成目录结构文件夹，打开终端，输入以下命令，终端将把目录结构直接打印出来：

tree

如果你需要控制打印目录的深度，那么可以加一个-L参数，后面加上目录深度值（1、2、3、…）：

tree -L [level]

如果你需要将内容写入Markdown文件中：

tree -L [level] > output.md

然后，你可以将output.md中的内容复制到你的Markdown文件中。

Reference

【1】https://blog.csdn.net/SoulmateY/article/details/135281617

CUDA和C/C++混编

Mon, 12 Aug 2024 00:00:00 GMT

CUDA和C/C++混编

1、编译方式

项目中用到cuda编程，写了kernel函数，需要nvcc编译器来编译。.c/.cpp的文件，假定用gcc编译。

如何混合编译它们，整体思路是：.cu文件编译出的东西，作为最终编译出的可执行程序的链接依赖。

具体说起来又可以有这几种情况：

分别编译各个文件，最后链接

将CUDA程序编译为静态库

将CUDA程序弄成动态库

其中后两种方式更工程化，基于makefile或CMake会更加方便。

假设手头上的文件为：

test1.cu
test2.c

则具体编译指令、编译脚本如下：

**方法1：**分别编译各个文件

$ nvcc -c test1.cu
$ gcc -c test2.c
$ gcc -o testc test1.o  test2.o -lcudart -L/usr/local/cuda/lib64

**方法2:**将cuda程序编译为静态库

$ nvcc -lib test1.cu -o  libtestcu.a
$ gcc test2.c -ltestcu  -L. -lcudart -L/usr/local/cuda/lib64

**方法3:**将cuda程序编译为动态库 以makefile为例

$ all: c
$ c:  libtestcu.so
$ gcc test2.c -ltestcu  -L. -lcudart -L/usr/local/cuda/lib64 -o testc
$ libtestcu.so:  test.cu
$ nvcc -o libtestcu.so  -shared -Xcompiler -fPIC test1.cu

Reference

【1】 https://www.cnblogs.com/zjutzz/p/10272424.html

【2】NVIDIA CUDA Compiler Driver

查看系统硬件信息

Mon, 12 Aug 2024 00:00:00 GMT

查看系统硬件信息

1、查看物理cpu个数

cat /proc/cpuinfo |grep "physical id"|sort |uniq|wc -l

2、查看核心数量

grep 'core id' /proc/cpuinfo | sort -u | wc -l

3、查看线程数

grep 'processor' /proc/cpuinfo | sort -u | wc -l

4、查看cpu型号

cat /proc/cpuinfo | grep name | cut -f2 -d: | uniq -c

Reference

【1】https://developer.aliyun.com/article/563422

CUDA编程入门

Wed, 12 Jun 2024 00:00:00 GMT

1、什么是CUDA？

CUDA是NVIDIA建立在GPU上的一个通用并行计算平台和编程模型，基于CUDA编程可以利用GPUs的并行计算引擎来更加高效地解决比较复杂的计算难题。

GPU包括更多的运算核心，其特别适合数据并行的计算密集型任务；

CPU的运算核心较少，但是其可以实现复杂的逻辑运算。

2、编程基础

用host指代CPU及其内存，而用device指代GPU及其内存，CUDA程序中既包含host程序，又包含device程序，它们分别在CPU和GPU上运行。同时，host与device之间可以进行通信，这样它们之间可以进行数据拷贝。

典型的CUDA程序的执行流程如下：

分配host内存，并进行数据初始化；
分配device内存，并从host将数据拷贝到device上；
调用CUDA的核函数在device上完成指定的运算；
将device上的运算结果拷贝到host上；
释放device和host上分配的内存。

上面流程中最重要的一个过程是调用CUDA的核函数来执行并行计算，kernel是CUDA中一个重要的概念，kernel是在device上线程中并行执行的函数，核函数用__global__符号声明（告诉编译器，在GPU上运行），在调用时需要用<<<grid, block>>>来指定kernel要执行的线程数量，在CUDA中，每一个线程都要执行核函数，并且每个线程会分配一个唯一的线程号thread ID，这个ID值可以通过核函数的内置变量threadIdx来获得。

由于GPU实际上是异构模型，所以需要区分host和device上的代码，在CUDA中是通过函数类型限定词开区别host和device上的函数，主要的三个函数类型限定词如下

__global__：在device上执行，从host中调用（一些特定的GPU也可以从device上调用），返回类型必须是void，不支持可变参数参数，不能成为类成员函数。注意用__global__定义的kernel是异步的，这意味着host不会等待kernel执行完就执行下一步。
__device__：在device上执行，单仅可以从device中调用，不可以和__global__同时用。
__host__：在host上执行，仅可以从host上调用，一般省略不写，不可以和__global__同时用，但可和__device__，此时函数会在device和host都编译。

必须要对kernel的线程层次结构有一个清晰的认识。首先GPU上很多并行化的轻量级线程。kernel在device上执行时实际上是启动很多线程，一个kernel所启动的所有线程称为一个网格（grid），同一个网格上的线程共享相同的全局内存空间，grid是线程结构的第一层次，而网格又可以分为很多线程块（block），一个线程块里面包含很多线程，这是第二个层次。线程两层组织结构如下图所示，这是一个gird和block均为2-dim的线程组织。

dim3 grid(3, 2);
dim3 block(5, 3);
kernel_fun<<< grid, block >>>(prams...);

一个线程需要两个内置的坐标变量（blockIdx，threadIdx）来唯一标识，它们都是`dim3`类型变量，其中blockIdx指明线程所在grid中的位置，而threaIdx指明线程所在block中的位置，如图中的Thread (1,1)满足：

threadIdx.x = 1
threadIdx.y = 1
blockIdx.x = 1
blockIdx.y = 1

一个线程块上的线程是放在同一个流式多处理器（SM)上的，但是单个SM的资源有限，这导致线程块中的线程数是有限制的，现代GPUs的线程块可支持的线程数可达1024个。有时候，我们要知道一个线程在blcok中的全局ID，此时就必须还要知道block的组织结构，这是通过线程的内置变量blockDim来获得。它获取线程块各个维度的大小。对于一个2-dim的block $(D_{x},D_{y})$，线程$(x,y)$  的ID值为$(x+y*D_{x})$  ，如果是3-dim的block$ (D_{x},D_{y},D_{z})$  ，线程 $(x,y,z)$ 的ID值为$(x+y*D_{x}+z*D_{x}*D_{y})$  。另外线程还有内置变量gridDim，用于获得网格块各个维度的大小。

kernel的这种线程组织结构天然适合vector,matrix等运算，如我们将利用上图dim结构实现两个矩阵的加法，每个线程负责处理每个位置的两个元素相加，代码如下所示。线程块大小为(16, 16)，然后将N*N大小的矩阵均分为不同的线程块来执行加法运算.

// Kernel定义
__global__ void MatAdd(float A[N][N], float B[N][N], float C[N][N])
{
    int i = blockIdx.x * blockDim.x + threadIdx.x;
    int j = blockIdx.y * blockDim.y + threadIdx.y;
    if (i < N && j < N)
        C[i][j] = A[i][j] + B[i][j];
}
int main()
{
    ...
    // Kernel 线程配置
    dim3 threadsPerBlock(16, 16);
    dim3 numBlocks(N / threadsPerBlock.x, N / threadsPerBlock.y);
    // kernel调用
    MatAdd<<<numBlocks, threadsPerBlock>>>(A, B, C);
    ...
}

由于SM的基本执行单元是包含32个线程的线程束，所以block大小一般要设置为32的倍数.

配置检查：（在进行CUDA编程前，可以先检查一下自己的GPU的硬件配置）

  int dev = 0;
    cudaDeviceProp devProp;
    CHECK(cudaGetDeviceProperties(&devProp, dev));
    std::cout << "使用GPU device " << dev << ": " << devProp.name << std::endl;
    std::cout << "SM的数量：" << devProp.multiProcessorCount << std::endl;
    std::cout << "每个线程块的共享内存大小：" << devProp.sharedMemPerBlock / 1024.0 << " KB" << std::endl;
    std::cout << "每个线程块的最大线程数：" << devProp.maxThreadsPerBlock << std::endl;
    std::cout << "每个EM的最大线程数：" << devProp.maxThreadsPerMultiProcessor << std::endl;
    std::cout << "每个SM的最大线程束数：" << devProp.maxThreadsPerMultiProcessor / 32 << std::endl;

    // 输出如下
    使用GPU device 0: GeForce GT 730
    SM的数量：2
    每个线程块的共享内存大小：48 KB
    每个线程块的最大线程数：1024
    每个EM的最大线程数：2048
    每个EM的最大线程束数：64

3、一些示例

CUDA编程中内存管理API。首先是在device上分配内存的**cudaMalloc函数**，这个函数和C语言中的malloc类似，但是在device上申请一定字节大小的显存。其中devPtr是指向所分配内存的指针。同时要释放分配的内存使用**cudaFree函数**，这和C语言中的free函数对应。

cudaError_t cudaMalloc(void** devPtr, size_t size);

重要的函数是负责host和device之间数据通信的**cudaMemcpy函数**：

cudaError_t cudaMemcpy(void* dst, const void* src, size_t count, cudaMemcpyKind kind)

其中src指向数据源，而dst是目标区域，count是复制的字节数，其中kind控制复制的方向：cudaMemcpyHostToHost, cudaMemcpyHostToDevice, cudaMemcpyDeviceToHost及cudaMemcpyDeviceToDevice，如cudaMemcpyHostToDevice将host上数据拷贝到device上。

向量加法
```
定义kernel：
```

// 两个向量加法kernel，grid和block均为一维
__global__ void add(float* x, float * y, float* z, int n)
{
    // 获取全局索引
    int index = threadIdx.x + blockIdx.x * blockDim.x;
    // 步长
    int stride = blockDim.x * gridDim.x;
    for (int i = index; i < n; i += stride)
    {
        z[i] = x[i] + y[i];
    }
}

stride是整个grid的线程数，有时候向量的元素数很多，这时候可以将在每个线程实现多个元素（元素总数/线程总数）的加法，相当于使用了多个grid来处理，这是一种[grid-stride loop](https://link.zhihu.com/?target=https%3A//devblogs.nvidia.com/cuda-pro-tip-write-flexible-kernels-grid-stride-loops/)方式，不过下面的例子一个线程只处理一个元素，所以kernel里面的循环是不执行的。下面我们具体实现向量加法：

int main()
{
    int N = 1 << 20;    // 二进制编码左移20
    int nBytes = N * sizeof(float);
    // 申请host内存
    float *x, *y, *z;
    x = (float*)malloc(nBytes);
    y = (float*)malloc(nBytes);
    z = (float*)malloc(nBytes);

    // 初始化数据
    for (int i = 0; i < N; ++i)
    {
        x[i] = 10.0;
        y[i] = 20.0;
    }

    // 申请device内存
    float *d_x, *d_y, *d_z;
    cudaMalloc((void**)&d_x, nBytes);
    cudaMalloc((void**)&d_y, nBytes);
    cudaMalloc((void**)&d_z, nBytes);

    // 将host数据拷贝到device
    cudaMemcpy((void*)d_x, (void*)x, nBytes, cudaMemcpyHostToDevice);
    cudaMemcpy((void*)d_y, (void*)y, nBytes, cudaMemcpyHostToDevice);
    // 定义kernel的执行配置
    dim3 blockSize(256);
    dim3 gridSize((N + blockSize.x - 1) / blockSize.x);
    // 执行kernel
    add << < gridSize, blockSize >> >(d_x, d_y, d_z, N);

    // 将device得到的结果拷贝到host
    cudaMemcpy((void*)z, (void*)d_z, nBytes, cudaMemcpyDeviceToHost);

    // 检查执行结果
    float maxError = 0.0;
    for (int i = 0; i < N; i++)
        maxError = fmax(maxError, fabs(z[i] - 30.0));
    std::cout << "最大误差: " << maxError << std::endl;

    // 释放device内存
    cudaFree(d_x);
    cudaFree(d_y);
    cudaFree(d_z);
    // 释放host内存
    free(x);
    free(y);
    free(z);

    return 0;
}

这里我们的向量大小为1<<20，而block大小为256，那么grid大小是4096，kernel的线程层级结构如下图所示：

常用脚本

Wed, 12 Jun 2024 00:00:00 GMT

常用脚本

从脚本文件中获取名称并处理

mapfile -t files < "SUFILE_2-55.txt"
for f in "${files[@]}:"; do
    echo "processing: $f"
    sfsuwrite<cspshot/splict_shot_data/$f tfile=cspshot/splict_hdr_data/$f endian=0 >${f}su
    cat ${f}su >>total.su
done

bash run.sh

介绍 $0、$1、$2、$#、$@、$*、$? 的含义

在编写 Linux bash shell 脚本时，经常会用到 $0、$1、$2、$#、$@、$*、$? 等参数。下面具体说明这些参数的含义。

假设执行 ./test.sh a b c 这样一个命令，则可以使用下面的参数来获取一些值：

$0 对应 ./test.sh 这个值。如果执行的是 ./work/test.sh，则对应 ./work/test.sh 这个值，而不是只返回文件名本身的部分。
$1 会获取到 a，即 $1 对应传给脚本的第一个参数。
$2 会获取到 b，即 $2 对应传给脚本的第二个参数。
$3 会获取到 c，即 $3 对应传给脚本的第三个参数。$4、$5 等参数的含义依此类推。
$# 会获取到 3，对应传入脚本的参数个数，统计的参数不包括 $0。
$@ 会获取到 "a" "b" "c"，也就是所有参数的列表，不包括 $0。
$* 也会获取到 "a" "b" "c"，其值和 $@ 相同。但 "$*" 和 "$@" 有所不同。 "$*" 把所有参数合并成一个字符串，而 "$@" 会得到一个字符串参数数组。
$? 可以获取到执行 ./test.sh a b c 命令后的返回值。在执行一个前台命令后，可以立即用 $? 获取到该命令的返回值。该命令可以是系统自身的命令，可以是 shell 脚本，也可以是自定义的 bash 函数。

当执行系统自身的命令时，$? 对应这个命令的返回值。当执行 shell 脚本时，$? 对应该脚本调用 exit 命令返回的值。如果没有主动调用 exit 命令，默认返回为 0。当执行自定义的 bash 函数时，$? 对应该函数调用 return 命令返回的值。如果没有主动调用 return 命令，默认返回为 0。

下面举例说明 "$*" 和 "$@" 的差异。假设有一个 testparams.sh 脚本，内容如下：

#!/bin/bash

for arg in "$*"; do
    echo "****:" $arg
done
echo --------------
for arg in "$@"; do
    echo "@@@@:" $arg
done

这个脚本分别遍历 "$*" 和 "$@" 扩展后的内容，并打印出来。

执行 ./testparams.sh 脚本，结果如下：

$ ./testparams.sh This is a test
****: This is a test
--------------
@@@@: This
@@@@: is
@@@@: a
@@@@: test

可以看到，"$*" 只产生一个字符串，for 循环只遍历一次。而 "$@" 产生了多个字符串，for 循环遍历多次，是一个字符串参数数组。

注意：如果传入的参数多于 9 个，则不能使用 $10 来引用第 10 个参数，而是要用 ${10} 来引用。

即，需要用大括号{}把大于 9 的数字括起来。例如，${10} 表示获取第 10 个参数的值，写为 $10 获取不到第 10 个参数的值。实际上，$10 相当于 ${1}0，也就是先获取 $1 的值，后面再跟上 0。如果 $1 的值是 "first"，则 $10 的值是 "first0"。

查看 man bash 里面对位置参数（positional parameters）的说明如下：

Positional Parameters A positional parameter is a parameter denoted by one or more digits, other than the single digit 0.Positional parameters are assigned from the shell's arguments when it is invoked, and may be reassigned using the set builtin command. Positional parameters may not be assigned to with assignment statements. The positional parameters are temporarily replaced when a shell function is executed.

When a positional parameter consisting of more than a single digit is expanded, it must be enclosed in braces.

即，最后一句提到，当位置参数由多位数字组成时，需要用大括号{}把多位数字括起来。

获取位置参数的个数

在 bash 中，可以使用 $# 来获取传入的命令行或者传入函数的参数个数。要注意的是，$# 统计的参数个数不包括脚本自身名称或者函数名称。例如，执行 ./a.sh a b，则 $# 是 2，而不是 3。

查看 man bash 的说明如下：

Special Parameters # Expands to the number of positional parameters in decimal.

可以看到，$# 实际上是扩展为位置参数（positional parameters）的个数，统计的参数不包括 $0。

Reference

【1】 https://segmentfault.com/a/1190000021435389

Linux系统

Tue, 12 Mar 2024 00:00:00 GMT

Linux系统

1、系统目录

bin：存放二进制可执行文件

boot：存放开机启动程序

dev：存放设备文件：字符设备、块设备

home：存放普通用户

etc：用户信息和系统配置文件 passwd、group

lib：库文件：libc.so.6

root：管理员宿主目录（家目录）

usr：用户资源管理目录

2、文件类型

Linux系统文件类型： 7/8 种

普通文件：-

目录文件：d

字符设备文件：c

块设备文件：b

软连接：l

管道文件：p

套接字：s

未知文件。

3、软硬链接

软连接：快捷方式
ln -s file file.hard
为保证软连接可以任意搬移，创建时务必对源文件使用绝对路径。

硬链接：
ln file file.hard
操作系统给每一个文件赋予唯一的 inode，当有相同inode的文件存在时，彼此同步。

删除时，只将硬链接计数减一。减为0时，inode 被释放。

4、用户操作

创建用户：

sudo adduser 新用户名        --- useradd

sudo useradd  -m -g siig -d /data1/userlogin/liguolong -s /bin/bash name

修改文件所属用户：

sudo chown 新用户名 待修改文件。

sudo chown wangwu a.c

删除用户：

sudo deluser 用户名

创建用户组：

sudo addgroup 新组名

修改文件所属用户组：

sudo chgrp 新用户组名 待修改文件。

sudo chgrp g88 a.c

删除组：

sudo delgroup 用户组名

使用chown 一次修改所有者和所属组：

sudo chown 所有者：所属组 待操作文件。

矩阵运算

Tue, 12 Mar 2024 00:00:00 GMT

矩阵运算

1、矩阵求导公式

什么是深度学习？（从函数逼近论的角度来理解）

Tue, 12 Mar 2024 00:00:00 GMT

Title: 什么是深度学习？（从函数逼近论的角度来理解）

URL Source: http://staff.ustc.edu.cn/~lgliu/Resources/DL/What_is_DeepLearning.html

Markdown Content: 什么是深度学习？

- 45****分钟理解深度神经网络和深度学习

刘利刚

中国科学技术大学图形与几何计算实验室

http://staff.ustc.edu.cn/~lgliu

【绪言】

近年来，人工智能（Artificial Intelligence, AI）和深度学习（Deep Learning, DL）非常火爆，在各个领域得到了广泛的应用。在笔者所从事的计算机图形学领域，也出现了越来越多的使用深度学习方法来解决各种问题的研究工作。2018年7月初，笔者首次在第七届中国科学技术大学《计算机图形学前沿》暑期课程上讲授和分享了笔者从数学（函数逼近论）的角度来对基于深度神经网络（Deep Neural Network, DNN）的深度学习的进行理解。之后，不断有学生来向笔者进一步询问和交流有关资料和问题。为了使学生们能够更好、更快理解和使用深度神经网络和深度学习，特撰写此文。

本文的目的是帮助非人工智能领域的学生（主要是计算机图形学领域的学生及笔者的学生）来搞懂深度学习（这里指狭义的深度学习，即基于DNN的深度学习）的基本概念和方法。笔者尝试用通俗的语言，从函数逼近论的角度来阐释深度神经网络的本质。由于笔者的主要研究领域为计算机图形学，而非人工智能领域，因此本文仅仅为笔者从外行的角度对基于DNN的深度学习的粗浅理解，而非人工智能领域对DNN和深度学习的权威解释。因而，笔者对其中的有些内容的理解是有限的，甚至是有误的。如有不当之处，还请读者指正！

一、 从数据拟合说起

在大学的《数学分析》、《微积分》或者《数值分析》中，大家都已学习并熟悉数据拟合问题及求解拟合问题的最小二乘法。

1.1. 数据拟合问题

在科学技术的各领域中，我们所研究的事件一般都是有规律（因果关系）的，即自变量集合与应变量集合之间存在的对应关系通常用映射来描述（特殊情况：实数集合到实数集合之间的映射称为函数）。这样能根据映射（函数）规律作出预测并用于实际应用。

有些函数关系可由理论分析推导得出，不仅为进一步的分析研究工作提供理论基础，也可以方便的解决实际工程问题。比如，适合于宏观低速物体的牛顿第二运动定律就是在实际观察和归纳中得出的普适性力学定律。

但是，很多工程问题难以直接推导出变量之间的函数表达式；或者即使能得出表达式，公式也十分复杂，不利于进一步的分析与计算。这时可以通过诸如采样、实验等方法获得若干离散的数据（称为样本数据点），然后根据这些数据，希望能得到这些变量之间的函数关系，这个过程称为数据拟合（Data fitting），在数理统计中也称为回归分析（Regression analysis）。

这里值得提一下，在实际应用中，还有一类问题是输出的结果是离散型的（比如识别图片里是人、猫、狗等标签的一种），此时问题称为分类（Classification）。

1.2. 数据拟合类型

我们先考虑最简单的情形，即实数到实数的一元函数。假设通过实验获得了个样本点。我们希望求得反映这些样本点规律的一个函数关系，如图1所示。

如果要求函数严格通过每个样本点，即

， (1.1)

则求解函数的问题称为插值问题（Interpolation）。

一般地，由于实验数据带有观测误差，因此在大部分情况下，我们只要求函数反映这些样本点的趋势，即函数靠近样本点且误差在某种度量意义下最小，称为逼近问题（Approximation）。若记在某点的误差为

(1.2)

且记误差向量为。逼近问题就是要求向量的某种范数最小。一般采用欧氏范数（范数）作为误差度量的标准（比较容易计算），即求如下极小化问题：

. (1.3)

图1. 数据拟合。左：输入的样本点；中：插值函数；右：逼近函数。

无论是插值问题还是逼近问题，一个首要的问题就是函数的类型的选择和表示问题，这是《函数逼近论》中的一个比较“纠结”的问题。

二、 函数逼近论简介

函数的表示是函数逼近论中的基本问题。在数学的理论研究和实际应用中经常遇到下类问题：在选定的一类函数中寻找某个函数，使它与已知函数（或观测数据）在一定意义下为最佳近似表示，并求出用近似表示而产生的误差。这就是函数逼近问题。称为逼近函数或拟合函数。

在函数逼近问题中，逼近函数的函数类可以有不同的选择；即使函数类选定了，在该类函数中确定的方式仍然是各式各样的；对的近似程度（误差）也可以有各种不同的定义。我们分别对这些问题进行理解和讨论。

2.1. 逼近函数类

在实际问题中，首先要确定函数的具体形式。这不单纯是数学问题，还与所研究问题的运动规律及观测数据有关，也与用户的经验有关。一般地，我们在某个较简单的函数类中去寻找我们所需要的函数。这种函数类叫做逼近函数类。

逼近函数类可以有多种选择，一般可以在不同的函数空间（比如由一些基函数通过线性组合所张成的函数空间）中进行选择。如下是一些常用的函数类。

(1) 多项式函数类

次代数多项式，即由次数不大于的幂基的线性组合的多项式函数：

, (2.1)

其中为实系数。

更常用的是由次Bernstein基函数来表达的多项式形式（称为Bernstein多项式或Bezier多项式）：

, (2.2)

其中Bernstein基函数

(2) 三角多项式类

阶三角多项式，即由阶数不大于的三角函数基的线性组合的三角函数：

, (2.3)

其中为实系数。

这些是常用的逼近函数类。在逼近论中，还有许多其他形式的逼近函数类，比如由代数多项式的比构成的有理分式集（有理逼近）；按照一定条件定义的样条函数集（样条逼近）；径向基函数（RBF逼近）；由正交函数系的线性组合构成的（维数固定的）函数集等。

2.2. 万能逼近定理

在函数逼近论中，如果一组函数成为一组“基”函数，需要满足一些比较好的性质，比如光滑性、线性无关性、权性（所有基函数和为1）、局部支集、完备性、正性、凸性等。其中， “完备性”是指，该组函数的线性组合是否能够以任意的误差和精度来逼近给定的函数（即万能逼近性质）？

对于多项式函数类，我们有以下的“万能逼近定理”：

【定理****2.1 **（Weierstrass逼近定理）】**对上的任意连续函数，及任意给定的，必存在次代数多项式，使得

(2.4)

Weierstrass逼近定理表明，只要次数足够高，次多项式就能以任何精度逼近给定的函数。具体的构造方法有Bernstein多项式或Chebyshev多项式等，这里不详细展开。

类似地，由Fourier分析理论（或Weierstrass第二逼近定理），只要阶数足够高，阶三角函数就能以任何精度逼近给定的周期函数。这些理论表明，多项式函数类和三角函数类在函数空间是“稠密”的，这就保障了用这些函数类来作为逼近函数是“合理”的。

2.3. 逼近函数类选择的“纠结”

在一个逼近问题中选择什么样的函数类作逼近函数类，这要取决于被逼近函数本身的特点，也和逼近问题的条件、要求等因素有关。

在实际应用中，这里其实存在着两个非常“纠结”的问题。

第一，选择什么样的逼近函数类？一般地，需要用户对被逼近对象或样本数据有一些“先验知识”来决定选择具体的逼近函数类。比如，如果被逼近的函数具有周期性，将三角函数作为逼近函数是个合理的选择；如果被逼近的函数具有奇点，将有理函数作为逼近函数更为合理，等等。

第二，即使确定了逼近函数类，选择多高的次数或阶数？比如，如果选择了多项式函数类，根据Lagrange插值定理，一定能找到一个次多项式来插值给定的个样本点。但如果较大，则这样得到的高次多项式很容易造成“过拟合”（Overfitting）。而如果选择的过小，则得到的多项式容易造成“欠拟合”（Underfitting）。如图2所示。过拟合或欠拟合函数在实际应用中是没有用的，因为它们的预测能力非常差！

图2. 用不同次数的多项式拟合样本点（蓝色点）。

左：欠拟合；中：合适的拟合；右：过拟合。

这里有个概念需要提及一下。一个逼近函数“表达能力”体现在该函数的未知参数（即公式(2.1)-(2.3)中的系数）与样本点个数的差，也称为“自由度”。如果逼近函数的未知参数越多，则表达能力越强。然而，在实际的拟合问题中，逼近函数的拟合能力并非越强越好。因为如果只关注样本点处的拟合误差的话，非常强的表达能力会使得样本点之外的函数值远远偏离期望的目标，反而降低拟合函数的预测性能，产生过拟合，如图2 (右)所示。

人们发展出各种方法来减缓（不能完全避免）过拟合。比如，剔除样本点中的噪声（数据去噪）、增加样本点数据量（数据增广）、简化预测模型、获取额外数据进行交叉验证、或对目标函数进行适当的正则化等。在此不详细叙述。

在实际应用中，如何选择拟合函数的数学模型（合适的逼近函数类及其阶数），并不是一开始就能选好，往往须通过分析确定若干模型后，再经过实际计算、比较和调整才能选到较好的模型。需要不断的试验和调试（称为“调参”过程），是个需要丰富经验的“技术活”。

2.4. 最小二乘法（Least Squares Method）

假设通过分析我们已经确定了逼近函数类及其次数。记基函数（一般线性无关）为。记为这些基函数所张成的线性空间（函数空间）。则逼近函数可记为

, (2.5)

其中为待定权系数。

关于最小二乘法的一般提法是：对给定的一组样本点数据，要求在函数类中找一个函数，使误差的模的平方，即式(1.3)，达到最小。

对于分析极小化误差(1.3)，可得关于系数向量的法方程

, (2.6)

从而可求得

. (2.7)

由于法方程是一个线性方程组，因此基于最小二乘法的函数求解也称为线性回归。

另外，我们可在误差项中加个权，表示不同点处的数据比重不同，此时称为加权最小二乘方法（Weighted least squares, WLS）。另外，还有移动最小二乘法（Moving least squares, MLS）等其他最小二乘法的改进方法。此处不详细叙述。

三、 稀疏表达和稀疏学习

在实际应用中， 2.3节中所述的两个“纠结”问题时有发生。人们发展出不同的方法来尝试解决。

3.1. 岭回归（Ridge Regression）

当数据量较少的情况下，最小二乘法（线性回归）容易出现过拟合的现象，法方程的系数矩阵会出现奇异（非满秩），此时回归系数会变得很大，无法求解。

这时在最小二乘法的结果（式(2.7)）中加一个小扰动，使原先无法求广义逆的情况变成可以求出其广义逆，使得问题稳定并得以求解，即

. (3.1)

事实上，这个解对应于如下极小化问题的解：

. (3.2)

其中，参数称为正则化参数（岭参数）。上述回归模型称为岭回归，其与最小二乘法的区别在于多了关于参数的范数正则项。这一项是对的各个元素的总体的平衡程度，即限制这些权稀疏的方差不能太大。

实际应用中，如果岭参数选取过大，会把所有系数均最小化（趋向于0），造成欠拟合；如果岭参数选取过小，会导致对过拟合问题解决不当。因此岭参数的选取也是一个技术活，需要不断调参。对于某些情形，也可以通过分析选择一个最佳的岭参数来保证回归的效果，在此不详细叙述。

3.2. Lasso回归（Least Absolute Shrinkage and Selection Operator）

Lasso回归的极小化问题为：

, (3.3)

其中，正则项为范数正则项。Lasso回归能够使得系数向量的一些元素变为0（稀疏），因此得到的拟合函数为部分基函数的线性组合。

3.3. 稀疏表达与稀疏学习

根据Lasso回归的分析，我们可通过对回归变量施加范数（范数为元素中非0元素的个数，在很多时候可以用范数近似）的正则项，以达到对回归变量进行稀疏化，即大部分回归变量为0（少数回归变量非0）。这种优化称为稀疏优化。也就是说，对回归变量施加范数能够“自动”对基函数进行选择，值为0的系数所对应的基函数对最后的逼近无贡献。这些非0的基函数反映了的样本点集合的“特征”，因此也称为特征选择。

通过这种方法，为了保证防止丢失一些基函数（特征），我们往往可以多选取一些基函数（甚至可以是线性相关的），使得基函数的个数比输入向量的维数还要大，称为“超完备”基（Over-complete basis）或过冗余基，在稀疏学习中亦称为“字典”。然后通过对基函数的系数进行稀疏优化，选择出合适（非0系数）的基函数的组合来表达逼近函数。

这在一定程度上克服了2.3节中所提出的两个“纠结”的问题。因为，这时可以选取较多的基函数及较高的次数，通过稀疏优化来选择（“学习”）合适的基元函数，也称为稀疏学习。另外，基函数（字典）和稀疏系数也可以同时通过优化学习得到，称为字典学习。

对于矩阵形式（比如多元函数或图像），矩阵的稀疏表现为矩阵的低秩（近似为核模很小），则对应着矩阵低秩求解问题。在此不详细叙述。

稀疏学习与最近十年来流行的压缩感知（Compressive sensing）理论与方法非常相关，也是机器学习领域的一种重要方法。其深厚的理论基础由华裔数学家陶哲轩（2006年国际数学家大会菲尔兹奖得主）、斯坦福大学统计学教授David Donoho（2018年国际数学家大会高斯奖得主）等人所建立，已成功用于信号处理、图像与视频处理、语音处理等领域。在此不详细展开介绍。

近年来，笔者及其团队成功地将稀疏学习的理论和方法推广用于三维几何建模与处理中，在计算机图形学领域已发表十余篇相关论文（包括在顶级期刊ACM Transactions on Graphics上发表了4篇论文）。有兴趣的读者可详细查看笔者的相关论文：

[3-1] Xu et al. Survey on Sparsity in Geometry Modeling and Processing. Graphical Models, 82, 160-180, 2015. （三维几何处理的稀疏优化方法的综述论文）

[3-2] Wang et al. Construction of Manifolds via Compatible Sparse Representations. ACM Transactions on Graphics, 35(2), Article 14: 1-10, 2016. （基于基函数稀疏选择的曲面生成）

[3-3] Xiong et al. Robust Surface Reconstruction via Dictionary Learning. ACM Transactions on Graphics (Proc. Siggraph Asia), 33(6), Article 1: 1-12, 2014. （基于字典学习的曲面重建）

[3-4] Zhang et al. Local Barycentric Coordinates. ACM Transactions on Graphics (Proc. Siggraph Asia), 33(6), Article 1: 1-12, 2014. （基于稀疏优化的局部重心坐标）

[3-5] Hu et al. Co-Segmentation of 3D Shapes via Subspace Clustering. Computer Graphics Forum (Proc. Symposium on Geometry Processing), 31(5): 1703-1713, 2012. （基于特征稀疏选择的三维形状共同分割）

[3-6] Jin et al. Unsupervised Upright Orientation of Man-Made Models. Graphical Models (Proc. GMP), 74(4): 99-108, 2012. （基于矩阵低秩优化的三维形状正向计算）

图3. 稀疏学习方法用于三维几何的建模与处理（笔者的工作）。

四、 高维的逼近函数

上面讨论了映射为一元函数的情形。上述的有关概念和方法同样可以推广至多元函数（）及向量值函数（）的情形（如图4）。

图4. 不同情形（维数）的逼近函数。

左上：一元函数；右上：多元函数；左下：一元向量值函数；右下：多元向量值函数。

4.1. 多元函数

假设有多元函数，即，的一组测量样本数据。设中的一组基函数为。要求函数

, (4.1)

使得误差

(4.2)

的平方和最小。这与式(1.3)和2.4节的极值问题完全一样。系数, 同样通过求解法方程得到。上述过程称为多元函数的最小二乘拟合。

在函数论中，高维空间中的基函数的构造也有许多方法。为了简便，在许多时候我们采用张量积形式的基函数，即每个基函数是各个维数的一元基函数的乘积形式。在计算机图形学和计算机辅助几何设计（CG&CAGD）领域经常采用。

4.2. 向量值函数

如果因变量有多个，即，称为向量值函数。比如空间螺旋线的参数方程

(4.3)

就是一个从一维到三维的向量值函数。如果自变量的维数比应变量的维数低，则自变量可看作为应变量的参数。在式(4.3)中，变量可看作为该螺旋线的参数。

对于向量值函数，可以看成是多个一元函数或多元函数（一般共享基函数）即可，所有处理方法（包括最小二乘法）都是对每个函数分别操作的，与前面单个函数的处理方法完全一样。如果用数学方式来表达，前面的很多符号由向量变为矩阵的形式而已。详细可查看《数学分析》。

五、 参数曲线曲面拟合

前面讨论的函数所能表达的曲线比较简单，无法表达封闭和多值的曲线。因此，在计算机图形学和计算机辅助几何设计中常用参数曲线曲面（本质是向量值函数，见4.2节）来表达几何形状，用于几何造型。另外，在计算机图形学中还有一种利用隐函数来表达曲线的方式，也常用于造型中，这里不展开介绍。

5.1. 二维参数曲线

从数学来看，一条曲线的本征维度是一维的，不论是从哪个维度的空间来看。从直观来看，该曲线能被“拉”成为一条直线或线段；即，一条有端点的曲线能和一条线段建立1-1对应，如图5（左）所示。因此，嵌入到二维空间中的曲线可由单个参数来表达，即有如下形式的参数形式：

(5.1)

其中为该曲线的参数，, 均为的函数，分别表示曲线上对应于参数的点的两个坐标分量。一般参数曲线表达为。本质上，这是一个从到的向量值函数。

5.2. 三维参数曲面

类似地，一张二维流形曲面的本征维度是二维的。一张曲面能与平面上的一块区域建立1-1对应，如图5（右）所示。因此，嵌入到三维空间中的曲面可由两个参数来表达，即有如下形式的参数形式：

(5.2)

其中为该曲面的参数，, 均为的二元函数，分别表示曲面上对应于参数的点的三个坐标分量。一般参数曲面表达为。本质上，这是一个从到的向量值函数。

图5. 参数曲线曲面。左：单参数曲线；右：双参数曲面。

5.3. 参数曲线曲面拟合

下面我们介绍如何使用参数曲线来拟合2D平面上的一组有序样本点。

参数曲线拟合的问题描述如下：给定平面上一组有序样本点，我们希望寻求一条拟合这些点的参数曲线关系。

如需决定一条拟合曲线，首先需要确定每个样本点所对应的参数。对于一组有序的样本点，所确定的一种参数分割，称之为这组样本点的参数化。参数化的本质就是找一组恰当的参数来匹配这一组样本点，以便使这条拟合出来的曲线美观、合理。

在参数曲线拟合中，样本点的参数化是个非常基本而重要的问题。不同的参数化，对拟合曲线的形状会产生很大的影响。图6显示了三种参数化（均匀参数化、弦长参数化和中心参数化）对拟合曲线形状的影响。

图6. 不同的参数化导致不同的参数曲线拟合结果。

类似地，如果利用参数曲面来拟合空间中给定的一组样本点，首先也需要确定这些样本点在平面上的参数化，如图7所示。在曲面参数化中，不仅需要建立样本点及其参数的一一对应，我们还希望参数区域的网格保持原始网格的一些重要的几何特性，比如角度、边长等。

图7. 三维曲面的参数化。

曲面参数化是计算机图形学中非常基础且重要的一个研究课题，也一直是研究热点之一。笔者及所在的课题组也在这个课题方面作了大量的工作，有兴趣的读者可详细查看笔者的相关论文：

（平面参数化）

[5-1] Ligang Liu, Lei Zhang, Yin Xu, Craig Gotsman, Steven J. Gortler. A Local/Global Approach to Mesh Parameterization. Computer Graphics Forum (Proc. Eurographics Symposium on Geometry Processing (SGP)), 27(5), 1495-1504, 2008.

[5-2] Ligang Liu, Chunyang Ye, Ruiqi Ni, Xiao-Ming Fu. Progressive Parameterizations. ACM Transactions on Graphics (Proc. Siggraph), 37(4), Article 41: 1-12, 2018.

（球面参数化）

[5-3] Xin Hu, Xiao-Ming Fu, Ligang Liu. Advanced Hierarchical Spherical Parameterizations. IEEE Transactions on Visualization and Computer Graphics, to appear, 2018.

[5-4] Chunxue Wang, Xin Hu, Xiaoming Fu, Ligang Liu. Bijective Spherical Parametrization with Low Distortion. Computers&Graphics (Proc. SMI), 58: 161-171, 2016.

[5-5] Chunxue Wang, Zheng Liu, Ligang Liu. As-Rigid-As-Possible Spherical Parameterization. Graphical Models (Proc. GMP), 76(5): 457-467, 2014.

（流形参数化）

[5-6] Lei Zhang, Ligang Liu, Zhongping Ji, Guojin Wang. Manifold Parameterization. Lecture Notes in Computer Science (Proc. Computer Graphics International), 4035, 160-171, 2006.

六、 从人工神经网络的观点来看拟合函数

为了讲清楚人工神经网络（Artificial Neural Network，ANN），下面我们先从神经网络的观点来看传统的拟合函数和曲线曲面。

6.1. 一元函数

对于一元的逼近函数

. (6.1)

可以看成为如图8的三层神经网络，其中只有一个隐层。隐层上有个节点，激活函数分别为基函数（从这里我们将基函数称为“激活函数”）。输入层到隐层的权设为常值1（图8左），也可以看成为将输入层的值“直接代入”（不做任何变换，用虚线表示）到激活函数（图8右）。隐层到输出层的权为基函数的组合系数。

中间隐层的输出节点所形成的向量可看作为输入量的“特征”。

现在我们开始用机器学习的语言来描述数据拟合的过程。整个神经网络就是由中间节点的激活函数及权系数所决定的一个函数(6.1)。我们称样本点, 为训练数据（Training set），称函数在训练数据上的误差度量为损失函数（Loss function）。通过训练数据来极小化损失函数得到权系数的过程称为“训练”或“学习”。如果损失函数取为(1.3)的形式，则网络的训练过程本质上就是前面所讲的最小二乘法（2.4节）。

图8. 一元逼近函数的神经网络。左：输入层到隐层的权系数均为常值1；

右：输入层到隐层看成为“直接代入”（用虚线表示）。

6.2. 多元函数和向量值函数

考虑一般的逼近函数。设中的一组基函数为。则函数可看成为如下图的一个三层的神经网络。注意这里隐层的激活函数都是维函数，从输入层到隐层也是直接代入。输出层的各个分量共享隐层的激活函数。

图9. 多元函数和向量值函数的神经网络。从输入层到隐层是变量直接代入到激活函数。

6.3. 拟合曲线曲面

拟合曲线可以看作为一个多层的神经网络，如下图所示。输入层（样本点）到参数化是一个变换，可看成为一个神经网络；参数化到输出层是一个变换（单变量基函数组合），也是一个神经网络。输出层的两个分量共享基函数。

隐层1的激活函数为双变量基函数；隐层3的激活函数为单变量基函数。中间隐层（隐层1、2、3）的输出节点所形成的向量均可分别看作为输入量在不同维数空间的“特征”。

图10. 拟合曲线的神经网络。输入层（样本点）到参数化是一个神经网络变换；

参数化到输出层是一个神经网络变换。

类似地，拟合曲面也可以看作为一个如下图的多层神经网络。

图11. 拟合曲面的神经网络。

从曲线曲面拟合的过程及神经网络结构来看，如果将整个网络进行优化，则拟合的过程是寻求样本点的参数化以及表达函数的基函数，使得拟合误差极小化。在这里，我们是知道给定样本点的“本征维数”，因此，人为设置了第一个隐层的维数为1（曲线）或2（曲面）。然而，在实际应用中，我们并不知道数据的本征维数，此时需要利用其他方法（比如流形学习或降维方法）来“检测”或“猜测”隐层的维数，或者直接根据经验来不断调参和测试。

需要提及的是，在计算机图形学中，传统的大部分方法是将参数化的问题和曲线曲面拟合问题分为两个问题来解决。有些工作专门做参数化，有些工作专门研究拟合问题。其中参数化的工作更为重要，直接决定了拟合曲线曲面的质量。此处不详述。

需要注意的是，本节只是从神经网络的观点来看曲线曲面的参数化和拟合的问题。在计算机图形学中，我们不是简单的通过上述网络来求参数化（单个样本点），而是要考虑更多的样本点一起来求解参数化。这个后面还会详细介绍。

七、 通用人工神经网络

有了上述的理解，我们现在来理解人工神经网络就非常容易了。

7.1. 函数拟合回顾

回顾前面所述的函数逼近论中的函数拟合问题，始终是存在着两个“纠结”。一是选择什么样的逼近函数类，即选择什么类型的基函数？二是选择多高的次数或阶数？

另一方面，如果从图8或图9的神经网络的观点来看，网络的结构设置都存在着如下两个“纠结”：

 隐层中的节点中使用什么样的激活函数（基函数）？

 隐层中设置多少个节点（基函数的次数）？

在传统逼近论中，上述两个问题就没有好方法来解决（第一个问题针对具体问题可预先设定），是通过不断试错来看结果的好坏来决定的。这是因为，虽然有些基函数的性质很好，但是次数或阶数过高（比如多项式基或三角函数基），就会产生震荡，也容易产生过拟合，使得拟合函数的性态不好。因此，一般不会采用次数或结束太高的基函数。为此，人们发展了分段拟合方法，即将数据分为若干段，每段分别拟合，各段的拟合函数保证一定的光滑性，称为样条函数。在逼近论和计算机图形学领域，人们发展出了很多漂亮的样条的理论与方法。

对于参数类型的高维曲线曲面，还存在着参数化的问题，这时还存在另一个纠结，就是要设置多少个隐层（图10和图11）？

7.2. 使用简单元函数作为激活函数

为了克服上述两个纠结的问题，是否可以通过其他形式来生成“基函数”？注意到，对于任意一个非常值的一元函数，这里我们称为元函数，其沿着方向的平移函数以及沿着方向的伸缩函数都与原函数线性无关。也就是说，如果能有足够多的变换所生成的函数，其线性组合所张成的函数空间就能有充分的表达能力。那么这些函数（可能都线性无关）是否能构成逼近一般函数的“基函数”呢？

一个自然的想法就是，我们能否以这个作为激活函数，让网络自动地去学习这些激活函数的变换，或者说去学习一些“基函数”，来表达所需要的拟合函数呢？这就是图12所示的神经元。变量乘以一个伸缩，加上一个平移（称为偏置“bias”），即变量的仿射变换，成为神经元的输入；然后通过激活函数复合后成为该神经元的输出。

图12. 一元（单变量）函数的神经元结构。

对于多变量的情形（多元函数），神经元的结构如图13所示。变量的线性组合，加上一个平移（称为偏置“bias”），即变量的仿射变换，成为神经元的输入；然后通过激活函数复合后成为该神经元的输出。

图13. 多元（多变量）函数的神经元结构。

不失一般性，我们下面就直接以多元函数的形式来介绍一般神经网络的结构。对于向量值函数（是多维的），则分别将的各个维数分别看作一个多元函数处理而已，这些函数共享节点（基函数）即可。

7.3. 单隐层神经网络

一个多元函数的神经网络的结构如图14所示，有一个输入层，一个隐层及一个输出层。输入层除了变量外，还有一个常数节点1；隐层包含多个节点，每个节点的激活函数都是，隐层的输出就是输入层节点的线性组合加偏置（即仿射变换）代入到激活函数的复合函数；输出层是这些复合函数的组合。

这个网络的所有权系数，（输入层与隐层之间的权及偏置项）及（隐层与输出层之间的权，此层一般不用偏置项）作为这个神经网络的参数变量，需要通过极小化损失函数来求解的。这个过程称为“训练”或“学习”。

与前面所述的逼近论中的拟合函数类似，网络的隐层的节点数是需要通过不断调试和尝试来确定的。隐层的节点输出称为输入数据)的“特征”。

图14. 多元（多变量）函数的单隐层神经网络结构。

整个网络的学习过程本质上就是在学习所有的系数参数。最后得到的拟合函数为一些函数的线性组合表达。这些组合函数实质上就是表达函数的“基函数”！

从函数逼近论的角度，我们可以这样来理解神经网络：神经网络的学习过程本质上是在学习基函数！这些基函数是通过激活函数通过平移和伸缩（变量的仿射变换）来得到的！

当然，天下没有免费的午餐。以前函数逼近论无法解决的两个“纠结”这里仍然存在：

第一个纠结是如何选取基函数？这里使用激活函数，然后学习其变换来得到。

第二个纠结是选择多少个基函数？这里为隐层的神经元个数。

从这个观点来看，神经网络本质上就是传统的逼近论中的逼近函数的一种推广。它不是通过指定的理论完备的基函数来表达函数的，而是通过简单的基元函数（激活函数）的不断变换得到的“基函数”来表达函数的。实质上是二层复合函数。

此时，我们当然要问个问题：将函数经过充分多的平移和伸缩（包括它们的组合）所线性张成的函数空间，其表达能力有多强？这个函数空间是否在所有函数空间是稠密的？如果问题是正确的，那么就是说，对于任何一个给定的函数，总能找到函数的多次平移和缩放的函数，其线性组合能够逼近给定的这个函数；也就是说，图14中的神经网络只要隐层的节点数足够多，该网络所表达的函数就能逼近任意的函数。

幸运的是，上述猜想在很多情况下是成立的！有以下的万能逼近定理所保证。

7.4. 万能逼近定理

记为空间中的单位立方体，我们在这个定义域中来描述万能逼近定理。记为上的连续函数空间，为上的可测函数空间，为上相对测度的可积函数空间（即）。

设给定一元激活函数，首先给出如下定义。

【定义7.1】称函数为压缩函数，如果单调不减，且满足

, .

【定义7.2】称函数为可分辨的，若对于有限测度，由

可得到

【定义7.3】记

为所有由激活函数变换及线性累加所构成的维函数空间（即具有个节点的单隐层神经网络所表达的维函数）。

【定理7.1】若是压缩函数，则在中一致稠密，在中按如下距离下稠密：

【定理7.2】若是可分辨的，则在中按连续函数距离下稠密。

【定理7.3】若是连续有界的非常值函数，则在中稠密。

【定理7.4】若是无界的非常值函数，则在中稠密。

上述定理这里就不详细解释，稍微有些实分析和泛函分析的基础就能看懂。用通俗的话来说，就是：对任意给定的一个中的函数，只要项数足够多，中就存在一个函数，使得在一定精度下逼近。也就是说，图14所表达的单隐层的神经网络所表达的维函数能够逼近中的任意一个函数。

根据上述定理可知，函数只要满足一定条件即可作为一个合适的激活函数。但还是存在着一个巨大的“纠结”，就是隐层中的节点数量该取多大，仍是未知的。在实际中，这个是要不断通过测试和调试来决定的，这个过程称为“调参”。

定理7.1-7.4的详细证明可见以下论文。

[7-1] K. Hornik, et al. Multilayer feedforward networks are universal approximations. Neural Networks, 2: 359-366, 1989.

[7-2] G. Cybenko. Approximation by superpositions of a sigmoidal function. Math. Control Signals System, 2: 303-314, 1989.

[7-3] K. Hornik. Approximation capabilities of multilayer feedforward networks. Neural Networks, 4: 251-257, 1991.

7.5. 深度神经网络：多隐层神经网络

将上述的神经网络的隐层进一步推广到多层，即可得到多隐层的神经网络，即深度神经网络（深度的意思就是多层）。其网络结构如图15所示。

由于每相邻的两层的节点都是全部连接的，因此在机器学习领域，也叫做全连接神经网络或多层感知机（Multi-Layer Perceptron, MLP）。

图15只是显示了的函数的神经网络的结构。对于一般的的向量值函数，只要将最后输出层多几个节点即可，即，每个维度分量都是一个的函数，共享了前面的所有网络层结构。

每个隐层的输出都可以看成输入数据在不同维数空间下的 “特征”。

注意不要在输出层使用激活函数。因为最后的输出就是那些基函数的线性组合表达即可。

从数学形式上看，深度神经网络就是一个多层复合函数。可以证明（Kolmogorov–Arnold表示定理），任意一个多元函数可以表示成若干个单变量函数的复合（事实上，只需要三层网络即可）。这为使用深度神经网络用来逼近任意高维函数提供了理论基础。但遗憾的是，该定理只证明了复合函数逼近任意函数的存在性，但具体使用什么样的函数未可知。

图15. 多元（多变量）函数的深度神经网络结构。

因此，深度神经网络也能很强地表达中的任意的函数。但在具体应用中，选用多少个隐层，每一隐层选用多少节点，这些都是需要根据损失函数的进行不断调试的。这个过程也称为“调参”。另外，从这个观点可以容易理解各种深度神经网络的工作机制，包括一般深度神经网络、卷积神经网络（CNN）、RBF神经网络、ELM等。

八、 深入理解深度神经网络

8.1. 激活函数

由7.4节中的万能逼近定理可知，激活函数的选择可以很多种。常用的激活函数如图16所示。

图16. 常用的激活函数。

在早期，Sigmoid函数和tanh函数是人们经常使用的激活函数。近年来，随着神经网络的隐层不断增加后，人们偏向于使用ReLU函数作为激活函数，这是因为ReLU函数的在x轴正向的导数是1，不容易产生梯度消失问题（见8.3节）。这里值得一提的是，如果使用ReLU函数作为激活函数，则最后生成的拟合函数为分片线性函数。

关于激活函数的理解和讨论，机器学习领域及互联网上有很多文章进行过解释，都是解释为“激活函数的主要作用是提供网络的非线性建模能力，提供了分层的非线性映射学习能力”等等。我们从逼近论的角度，将非线性激活函数理解为拟合函数的“基函数”生成器（如果激活函数为线性的，则无法生成表达非线性函数的基！），训练神经网络就是在学习这些基函数，这是一种全新的观点，也是非常容易理解的。

8.2. 反向传播算法（BP优化算法）

从数学上看，深度神经网络就是一个多层复合函数。在机器学习中，这个复合函数的好坏依赖于对目标函数最大化或者最小化的过程，我们常常把最小化的目标函数称为损失函数（Loss function），它主要用于衡量机器学习模型（此处为深度神经网络）的预测能力。常见的损失函数有均方误差（L2误差）、平均绝对误差（L1误差）、分位数损失、交叉熵、对比损失等。损失函数的选取依赖于参数的数量、异常值、机器学习算法、梯度下降的效率、导数求取的难易和预测的置信度等若干方面。这里就不展开讨论。

给定了一批训练数据，计算神经网络的问题就是通过极小化损失函数来找到网络中的所有权值参数（包括偏置参数）。这个过程本质上就是利用这个神经网络函数来拟合这些数据，这个过程也称为“训练”或“学习”。

误差反向传播算法（Error Back Propagation，BP）是神经网络训练时采用的一种通用方法。本质是随机梯度下降法。最早见于如下论文：

[8-1] David E. Rumelhart, Geoffrey E. Hinton, and Ronald J. Williams. Learning internal representations by back-propagating errors. Nature, 323(99): 533-536, 1986.

由于整个网络是一个复合函数，因此，训练的过程就是不断地应用“复合函数求导”（链式法则）及“梯度下降法”。反向传播算法从神经网络的输出层开始，利用递推公式根据后一层的误差计算本层的误差，通过误差计算本层参数的梯度值，然后将差项传播到前一层。然后根据这些误差来更新这些系数参数。

值得一提的是，梯度下降法并不是唯一的优化方法。也有不少人使用其他优化方法，比如ADMM方法，来作为优化器优化深度神经网络的求解。

8.3. 什么是好的激活函数？

由万能逼近定理可知，只要网络规模设计得当，使用非线性函数作为激活函数（比如8.1节中常用的激活函数）的逼近能力都能够得到保证。

然后，由上一节的反向传播算法可知，算法过程中计算误差项时每一层都要乘以本层激活函数的导数，因此，会发生很多次的导数连乘。如果激活函数的导数的绝对值小于1，多次连乘之后误差项很快会衰减到接近于0；而参数的梯度值由误差项计算得到，从而导致前面层的权重梯度接近于0，参数不能得到有效更新，这称为“梯度消失”问题。与之相反，如果激活函数导数的绝对值大于1，多次连乘后权重值会趋向于非常大的数，这称为“梯度爆炸”。长期以来，这两个问题一直困扰神经网络层次无法变得很深。

最近几年，ReLU函数被经常使用作为深度神经网络的激活函数。有两个主要理由：

 该函数的导数为sgn（忽略在0处不可导的情形），计算简单，在正半轴导数为1，有效的缓解了梯度消失问题；

 虽然它是一个分段线性函数，但它具有非线性逼近能力；使用ReLU激活函数的深度网络的本质是用分段（分片）线性函数（超平面）去逼近目标。

后来，人们在ReLU的基础上又改进得到各种其他形式的激活函数，包括ELU、PReLU等。

8.4. 多个隐层的几何意义

现在我们已经理解了深度神经网络的本质，就是一个复杂的多层复合函数。训练的过程就是在求激活函数变换得到的“基函数”，因此，训练神经网络的本质就是在“学习基函数”。这跟稀疏学习中的“字典学习”非常类似。殊途同归！

我们来看一下深度神经网络所表达的拟合函数与传统所用的拟合函数（2.1节）的类比与区别：

(1) 传统的拟合函数是在某一函数类（由某些具有良好性质的基函数所张成的函数空间）中进行选择。基函数是预先给定的，个数也是预先设定的（或者稀疏选择的）。系统的求解变量是基函数组合系数；

(2) 神经网络所表达的拟合函数是由某一激活函数对变量的平移和伸缩变换而来，个数是预先设定的（神经元个数）。系统的求解变量是基函数的变换，因此可以看成是在学习基函数；

(3) 传统的拟合函数也是一种神经网络（见第6节），因此也可以拓展成深度网络（复合函数），但问题是次数或阶数经过复合后会变得非常高，更易造成过拟合；

(4) 多层神经网络中的不同层所用的激活函数也可以使用传统的基函数。因此，还可推广为更一般的深度神经网络。

那么为何要用多个隐层呢？事实上，通过6.3节的内容就不难理解了。每个隐层就是将前一层的数据作为输入（当然也包括输入层数据）在当前这个维数的空间中的一种映射，本质上就是在做“参数化”！

如果当前层的维数小于上一层的维数，就相当于将上一层的数据参数化到低维空间中。当然也可以参数化到高维空间，以提高自由度。

在6.3节中，对于三维曲面，我们已知它是二维流形，因此，我们知道将其映射到二维作为参数域就很自然了。因此有了图11这样的网络结构。

但对于一般的数据（比如人脸数据），是在背景空间（ambient space）上观测的，可能数据的维数非常高（比如1000x1000的图像按照像素个数的维数达到100万维）。但这些数据并不会充满整个高维空间，会具有低维的结构（称为本征维数），即数据落在一个低维子空间（或低维流形）上，并呈现一定的概率分布。从数据的角度来看，一个嵌入到高维空间的低维流形本质上就是一个参数曲面，参数域是那个低维空间。因此，将高维数据参数化到低维的空间是可行的。

这里也出现了两个纠结的问题。

第一，对于一个实际数据拟合问题，应该设置多少个隐层？

第二，每个隐层应该设置多少个节点（该隐层的维数）？

在机器学习领域，隐层的层数称为网络的深度，隐层的维数成为网络的宽度。对于基于深度神经网络的学习，到底是越深越好，还是越宽越好？

从数学上来看，网络越深，表示一个复杂的函数可以经过多次参数化的变换，映射到最终的目标。这个是合理的。举个例子，比如我们想将一个三维网格曲面参数化到一个平面，如果这个输入的曲面比较复杂，开口（参数化边界）很小，则要将曲面一次性展开（到的映射）比较困难。此时，可以多进行几次从到的映射，将曲面先在慢慢张开，每次张开的映射比较容易表达和计算。最后再映射到上就相对容易了，当然还可进行多次从到的映射，生成更好的参数化。注意其中任何一个映射都可以是用一个神经网络来表达。

图17. 带有特征的曲面的拟合。(a) 原始输入三维数据；(b) 为(a)的简单参数化（Floater参数化）；(c) 为优化过后的参数化；(d) 最后的拟合曲面。

在计算机图形学中，我们针对曲面展开及拟合问题，在如下的工作中用到了这种思想。

[8-2] Linlin Xu, Ruimin Wang, Zhouwang Yang, Jiansong Deng, Falai Chen, Ligang Liu. Surface Approximation via Sparse Representation and Parameterization Optimization. Computer-Aided Design (Proc. SPM), 78: 179-187, 2016.

如图17所示，(a) 为一个带有尖锐特征的输入点云，如果将其简单参数化为(b)，在其上构建的拟合曲面很难表现曲面的尖锐特征。这时我们对(b)中的参数化再做一个映射（优化）为(c)，这时在其上做的拟合曲面则能很好地表现出尖锐特征。注意，这里生成拟合曲面的基函数中我们采用了非光滑基函数（采用非光滑基函数来表现曲面特征的思想首次在我们的如下论文中所采用）。因此，上述工作本质上是一个使用5层神经网络（3个隐层）来优化拟合曲面。

[8-3] Ruimin Wang, Ligang Liu, Zhouwang Yang, Kang Wang, Wen Shan, Jiansong Deng, Falai Chen. Construction of Manifolds via Compatible Sparse Representations. ACM Transactions on Graphics, 35(2), Article 14: 1-10, 2016.

这里顺便提一下，在计算机图形学中，最近一些年有不少工作在做曲面参数化的优化工作（比如满足无翻转、低扭曲等约束）。从机器学习的观点来看，就是在做更多的参数映射的优化计算。当然，这些工作并不能简单地看成一个深度神经网络来做。这是因为，对参数化的问题，我们是知道曲面（所有数据）的整体结构的，而不只是一些离散的采样点。因此，我们在做参数化优化的时候，我们可以充分利用曲面的整体结构来得到一些几何度量来满足各种约束，而这些是神经网络优化所做不到的！

总之，对于第一个问题，隐层越多，表示网络越深，确实会使得最后的映射带来更好的表现。其数学本质是将输入数据不断在不同的空间中进行参数化映射。最后得到的映射（可能非常复杂的映射）表达为若干个相对简单映射的复合。对于多隐层的解释和讨论，机器学习领域及网上有很多文章进行过解释，大部分都解释为“提取数据的特征”等等。我们从逼近论的角度（结合三维曲面拟合的例子），将多隐层优化看成数据在不同维数空间的参数化，是非常容易直观理解的。

对第二个问题，每个隐层的具体的节点数或维数，该如何设置呢？对于一般的数据这个就很难直观确定了，一般要根据经验。当然，也有一些办法来进行指导，我们将在下一节中理解。

8.5. 流形学习（数据降维）简介

对于一般的数据，我们并不知道其本征维数（即参数域空间），那么映射（参数化）到多少维空间是合适的呢？

事实上，这个也是个非常纠结的问题！这个问题就是寻求高维数据的本征维数，在机器学习领域称为流形学习（Manifold learning），或降维问题（Dimension reduction）。如图18所示，数据是在三维空间给出的（B），每个点是3个坐标，看起来是三维数据；但其本质上位于三维空间的一张曲面上，即二维流形曲面上（A），其本征维数是2。因此，可以将其一一映射到平面上（C）。

图18. 流行学习。（图片来自论文[8-5]）

提到流形学习，不能不提到如下的两篇开山之作（同时发在Science 2000的文章）：

[8-4] Roweis, Sam T and Saul, Lawrence K. Nonlinear dimensionality reduction by locally linear embedding. Science, 290(5500). 2000: 2323-2326.

[8-5] Tenenbaum, Joshua B and De Silva, Vin and Langford, John C. A global geometric framework for nonlinear dimensionality reduction. Science, 290(5500). 2000: 2319-2323.

流形学习在本世纪初的前一个十年是一个研究热点（由上面两篇Science论文带起来的）。至今已发展出了许多方法，从简单的线性方法，比如PCA；到后面的非线性方法，比如局部线性嵌入（LLE），等距映射法（Isomap），Laplace特征映射，局部保投影法（LPP）等。这里不详细介绍。

需要指出的是，正如第6节所讲的三维曲面参数化的计算，我们计算数据的本征维数的时候，是需要利用所有数据的信息及其几何或拓扑结构一起来分析的，而不能像神经网络训练那样，仅仅将数据灌到神经网络中去更新权系数。

8.6. 端对端学习（End-to-end learning）

在传统的机器学习中，很多任务的输入数据的维数都非常大，不易直接处理。往往需要先降到合适的维数，然后再选择合适的预测模型来做拟合。

传统机器学习的流程一般由两个主要的模块组成。第一个模块称为特征工程，将原始输入数据（高维向量）变换为一个低维向量，即，用这个低维向量来作为表达输入数据的特征（或描述子，feature or descriptor）。不同的人有不同的方法来计算这个低维特征，称为特征抽取（Feature extraction），如图19显示了不同的图像特征抽取方法。各种计算的特征都有一定的实用范围，因此，有人就提出如何选择或组合各种特征得到更好的特征，这是特征工程的另一个子问题，称为特征选择（Feature selection）。针对三维形状分割，我们发现对三维局部块的众多描述子并不是串联起来一起使用更好，而是针对不同的形状的部位使用不同的描述子会更好，于是我们使用稀疏选择的方法来选择形状描述子用于形状分割，详细可见如下论文。

[8-6] Ruizhen Hu, Lubin Fan, Ligang Liu. Co-Segmentation of 3D Shapes via Subspace Clustering. Computer Graphics Forum (Proc. Symposium on Geometry Processing), 31(5): 1703-1713, 2012.

图19. 图像的各种特征抽取方法。

由于这种特征是通过人为设计的算法来得到的，因此这种特征称为人工特征（Hand-crafted features）。人工特征的抽取需要人们对输入数据的认知或者领域知识（Domain knowledge），因此在很多情况下会局限于人的经验和认知。

第二个模块称为预测模型，即选用什么样的预测方法来拟合给定的数据，我们前面所讲的拟合就是指这个过程。预测模型的目标就是希望学习到的模型在预测未知目标时越精确越好。一般要考虑模型的复杂度及精确度等因素。在机器学习领域有非常多的方法，这里不一一介绍。

上述两个模块中的每个模块都是一个独立的任务，其结果的好坏会影响到下一步骤，从而影响整个训练的结果，这是非端到端的，如图20（上）所示。

特征提取的好坏异常关键，甚至比预测模型还重要。举个例子，对一系列人的数据分类，分类结果是性别（男或女），如果你提取的特征是头发的颜色，无论分类算法如何，分类效果都不会好；如果你提取的特征是头发的长短，这个特征就会好很多，但是还是会有错误；如果你提取了一个超强特征，比如染色体的数据，那你的分类基本就不会错了。

这就意味着，特征需要足够的经验去设计，这在数据量越来越大的情况下也越来越困难。于是就出现了端到端的网络，特征可以自己去学习。所以特征提取这一步也就融入到算法当中，不需要人来干预了。即不需要将任务分为多个步骤分步去解决，而是从输入端的数据直接得到输出端的结果。前面介绍的深度神经网络就是一个端到端的学习方法。如图20（下）所示。

端到端学习的好处在于，使学习模型从原始输入到最终输出，直接让数据“说话”，不需人工设计的模块；给模型更多可以根据数据自动调节的空间，增加模型的整体契合度。

图20. 非端到端的学习（上）与端到端的学习（下）。

但端到端学习也有不足。第一，端到端的深度神经网络需要大量的样本数据才能工作得很好，因此很多公司都在花费大量的人力物力去生成标注数据（一般通过人工标注，催生了很多专门做数据标注的外包公司）；第二，人工设计的特征并不是都不能用的，有些人工特征还是能代表着人类智能的，是可以用来作为合理的特征的，而端到端的学习无法用这些特征。当然，通过适当的改造和结合，也可以集成人工特征到深度神经网络中，这里就不展开讨论。

8.7. 深度学习成功的原因

基于深度神经网络的端到端学习在最近几年取得很大的成功，被大量应用与计算机视觉、语音识别、自然语音处理、医学图像处理等领域中。从数学本质上来看，神经网络就是一个映射函数而已，在上世纪50年代就有了感知机，但为什么以前没有火呢？主要有以下的两方面的原因。

第一，之前没有那么大规模的数据量；

第二，以前的工程技术（先进优化算法及支持大规模并行计算的GPU硬件）无法求解的很深的神经网络。

因此，在上个世纪90年代，各种浅层模型大行其道，比如只有一层隐层的支撑向量机（Support Vector Machine，SVM）以及没有隐层的逻辑回归方法（Logistic Regression，LR）等。

直到最近几年，随着各种传感器的大量使用以及移动互联网的广泛应用，能够获取和产生海量（PB级甚至ZB级）的数据（比如文本、图像、语音等）。特别是ImageNet图像数据库的诞生以及基于该数据库的各种竞赛，直接将计算机视觉领域中的深度学习的研究与应用推向了“落地”，催生了大量的计算机视觉的人工智能公司。

8.8. 过拟合

自从深度学习火了后，各种深度神经网络（或CNN网络）随之产生了，比如2012年的AlexNet有8层；2014年的VGG-19有19层；2014年的GoogleNet有22层；2015年的ResNet有152层！甚至还出现了上千层的深度神经网络！

从数学上可知，拟合函数所带的参数的个数与样本数据的个数之间的差代表着这个拟合函数的“自由度”。网络越来越“深”后，拟合模型中的可调整参数的数量就非常大，通常能达到百万计甚至几十亿级。因此，层数很大的深度网络（模型过于复杂）能够表达一个自由度非常大的函数空间，甚至远高于目标函数空间（过完备空间），即自由度远大于0。这样就很容易导致过拟合（Overfitting），如前面所讨论过的图2（右）所示。

过拟合可以使得拟合模型能够插值所有样本数据（拟合误差为0！）。但拟合误差为0不代表模型就是好的，因为模型只在训练集上表现好；由于模型拟合了训练样本数据中的噪声，使得它在测试集上表现可能不好，泛化性能差。为此，人们采取了不同的方法来缓解过拟合（无法完全避免），比如正则化、数据增广、Dropout、网络剪枝等。

在使用深度神经网络来做深度学习的应用中，很多工作都是直接使用现有的深度神经网络，或者改造现有的深度神经网络。如果网络设计不够好，大部分结果都可能有过拟合的现象。

在实际应用中，我们可以挑选样本数据中的一部分作为训练数据集，其他的作为测试数据集。如果网络在训练数据集上表现好（即损失函数很小），而在测试数据集上表现不够好，那么就可能发生了过拟合，此时就适当减少网络的层数或者节点数。这个过程是需要有耐心，可能需要花费很长时间才能调到一个合适的网络。需要靠感觉、经验和运气。因此，有人戏称调试深度神经网络的过程为“炼丹”。

8.9. 类比神经科学的解释

我们已从函数逼近论的角度来理解了人工神经网络本质是传统逼近函数的一个推广，由人工选取基函数到自动学习基函数，由人工提取特征到自动计算特征（参数化），能够较容易理解人工神经网络学习是如何工作的。

在机器学习领域，人们从生物神经网络的角度来解释和理解人工神经网络的工作原理，将人工神经网络看成为一个可以模拟人脑工作行为的函数。

在生物神经科学（Neuroscience，包括脑科学、认知神经科学等）的研究中，人们发现，人体的神经元通过树突接受信号。这些信息或信号随后被传递到脑细胞或细胞体。在细胞体内部，所有的信息将被加工生成一个输出。当该输出结果达到某一阈值时，神经元就会兴奋，并通过轴突传递信息，然后通过突触传递到其他相连的神经元。神经元间传输的信号量取决于连接的强度。如图21（左）。

我们来类比人工神经网络：如果把树突想象成人工智能网络中基于突触感知器的被赋予了权重的输入。然后，该输入在人工智能网络的“细胞体”（神经元）中相加。如果得出的输出值大于阈值单元，那么神经元就会“兴奋”（激活），并将输出传递到其它神经元，如图21（右）。

图21. 左：人脑神经元结构；右：从生物神经网络类比得出的人工神经元结构。

（图片来自互联网）

在计算机视觉领域，人们也从视觉神经科学（Visual Neuroscience）中类比来解释了在计算机视觉领域用得最多的卷积神经网络（CNN）的工作机理。

图22. 视觉皮层结构。（图片来自互联网）

由视觉机理的研究发现，动物大脑的视觉皮层具有分层结构。眼睛将看到的景象成像在视网膜上，视网膜把光学信号转换成电信号，传递到大脑的视觉皮层（Visual cortex），视觉皮层是大脑中负责处理视觉信号的部分。1959年，有科学家进行了一次实验，他们在猫的大脑初级视觉皮层内插入电极，在猫的眼前展示各种形状、空间位置、角度的光带，然后测量猫大脑神经元放出的电信号。实验发现，当光带处于某一位置和角度时，电信号最为强烈；不同的神经元对各种空间位置和方向偏好不同。这一成果后来让他们获得了诺贝尔奖。

目前已经证明，视觉皮层具有层次结构。从视网膜传来的信号首先到达初级视觉皮层（primary visual cortex），即V1皮层。V1皮层简单神经元对一些细节、特定方向的图像信号敏感。V1皮层处理之后，将信号传导到V2皮层。V2皮层将边缘和轮廓信息表示成简单形状，然后由V4皮层中的神经元进行处理，它颜色信息敏感。复杂物体最终在IT皮层（inferior temporal cortex）被表示出来。

卷积神经网络可以看成是上面这种机制的简单模仿。它由多个卷积层构成，每个卷积层包含多个卷积核，用这些卷积核从左向右、从上往下依次扫描整个图像，得到称为特征图（feature map）的输出数据。网络前面的卷积层捕捉图像局部、细节信息，有小的感受野，即输出图像的每个像素只利用输入图像很小的一个范围。后面的卷积层感受野逐层加大，用于捕获图像更复杂，更抽象的信息。经过多个卷积层的运算，最后得到图像在各个不同尺度的抽象表示（由底层到高层的特征表达），如图23所示。

图23. 基于卷积神经网络的深度学习所得到的人脸图像的分层特征。

（图片来自于Stanford大学的论文）

笔者认为，利用神经科学的神经元或神经网络来解释深度学习中的人工神经网络，这仅仅是类比而已。从我们的分析可知，深度学习中的人工神经网络并没有真正的认知和学习！如果我们人类对自己的认知系统无法完全了解的话，我们是很难发展出真正的人工智能技术。

8.10. 深度人工神经网络的局限：保持结构的映射

我们从数学上理解了深度人工神经网络本质上是表达不同维数空间之间的一个映射（函数）。给了一些样本点后，通过调整网络的参数权系数，不断极小化损失函数，从而达到最好的拟合结果得到了拟合函数。

这个拟合过程只极小化了逐点的误差或者累积逐点误差，而无法考虑点与周围点之间的其他信息（比如邻域几何结构、局部几何度量、流形的整体拓扑结构等）。如果要考虑点之间的几何与拓扑的结构信息，则深度人工神经网络就无能为力（当然一定要改造也是可以的），这时就需要其他的数学方法了。有点像数学分析中，逐点收敛和一致收敛，逐点连续和一致连续的区别。

例如，前面介绍的流形学习中，LLE方法保持每个样本点与它相邻的多个点的线性组合（体现了局部线性）来重构低维空间的点的分布，相当于用分段的线性面片近似代替复杂的几何形状，样本投影到低维空间保持这种线性重构关系，如图24（左）所示。Isomap方法希望保持数据在低维空间的映射之后能够保持流形上的测地线距离，即全局的几何结构，如图24（右）所示。

图24. 流形学习。左：保持局部的几何信息（LLE）；右：保持全局的距离信息（Isomap）。

（图片分别来自于论文[8-4]和[8-5]）

再如，在计算机图形学和几何处理领域，我们做的很多映射（比如三维网格曲面的参数化），也需要保持曲面上的某些几何性质（保角度、保面积、保形等），也发展出许多不同的求解映射的方法和技巧。例如，以下两个工作是我们做的有关三维曲面参数化到二维平面的工作，第一个工作是曲面参数化工作的经典方法之一，已经被集成到3D System公司的建模软件以及著名的计算几何算法CGAL库（The Computational Geometry Algorithms Library）中。第二个工作是今年我们最新的一个工作，能快速生成无翻转和低扭曲的网格参数化，论文即将在下周的Siggraph 2018会议上汇报。

[8-7] Ligang Liu, Lei Zhang, Yin Xu, Craig Gotsman, Steven J. Gortler. A Local/Global Approach to Mesh Parameterization. Computer Graphics Forum (Proc. Eurographics Symposium on Geometry Processing (SGP)), 27(5), 1495-1504, 2008.

[8-8] Ligang Liu, Chunyang Ye, Ruiqi Ni, Xiao-Ming Fu. Progressive Parameterizations. ACM Transactions on Graphics (Proc. Siggraph), 37(4), Article 41: 1-12, 2018.

在计算机图形学中，有时我们也需要将三维空间的二维流形曲面映射到另一个规则二维流形曲面，比如球面上，这时称为球面参数化。如读者有兴趣可阅读我们如下的3篇有关球面参数化的工作。

[8-9] Xin Hu, Xiao-Ming Fu, Ligang Liu. Advanced Hierarchical Spherical Parameterizations. IEEE Transactions on Visualization and Computer Graphics, to appear, 2018.

[8-10] Chunxue Wang, Xin Hu, Xiaoming Fu, Ligang Liu. Bijective Spherical Parametrization with Low Distortion. Computers&Graphics (Proc. SMI), 58: 161-171, 2016.

[8-11] Chunxue Wang, Zheng Liu, Ligang Liu. As-Rigid-As-Possible Spherical Parameterization. Graphical Models (Proc. GMP), 76(5): 457-467, 2014.

另外，在计算机图形学及计算机辅助几何设计领域，我们还有独特的曲线和函数的构造方法，如通过Bernstein基函数构造的Bezier曲线曲面，通过B样条基构造的B样条曲线曲面（分段Bezier曲线曲面），以及更一般的非均有有理B样条曲线曲面，通过控制顶点就能很直观控制曲线曲面的形状，而且发展出非常完备的理论及设计方法，如图25所示。这些独特的曲线曲面的构造方法也是我们领域独特的，已成为现代工业中产品曲面造型的工业标准（标准数学表达）。

图25. NURBS曲线曲面：产品曲面造型的工业标准。（图片来源与互联网）

九、 实战深度神经网络学习

由于本文是面向非机器学习专业介绍深度学习的，因此，笔者在这里只是大致介绍一下各种基于深度神经网络的学习方法的实际技巧，不详细展开讨论，有兴趣的读者可查阅更专业的书籍或论文。

9.1. 看懂各种深度神经网络结构

从数学上来看，深度神经网络仅仅是一种函数的表达形式，是复杂的多层复合函数。由于它有大量的可调参数，而且近年来随着大数据、优化算法和并行计算GPU硬件的发展，使得用大规模的神经网络来逼近和拟合大数据成为可能。至今，不同领域的研究工作者及产业界工作者已将深度神经网络应用到各行各业的各个问题，而且提出了各种形式、各种结构的深度网络结构，使人眼花缭乱，似乎难以捉摸。但事实并非如此！

万变不离其宗，神经网络就是一个多层复合函数。网络结构发生改变，就是说函数的复合形式发生了变化。因此，只要掌握了这条原则，各种复杂的神经网络你就能轻松看懂。亦可参考互联网上的“一文看懂25个神经网络模型”一文。

图26. 多层神经网络所表达的函数：可以看成前面的若干层网络所表达的函数（蓝色）与后面若干层网络所表达的函数（红色）的复合。

简单地说，看懂各种神经网络结构只需看懂如下3个要素（具体解释就不详细展开了）：

(1) 神经元与激活函数：神经元接收什么数据，通过什么样的激活函数输出数据。人们发明了许多不同种类的神经元，比如，池化神经元和插值神经元（Pooling and interpolating cells）、概率神经元（Mean and standard deviation cells）、循环神经元（Recurrent cells ）、长短期记忆神经元（Long short term memory cells）、门控循环神经元（Gated recurrent cells）等。不管什么样形式和名称的神经元，我们只要搞明白神经元是通过什么样的函数来将接收数据变为输出数据，不同之处就在接收数据和激活函数不同而已，如图21（右）所示。

(2) 神经网络结构：不同的神经网络就是不同的多层复合形式的函数。比如，卷积神经网络（Convolutional Neural Network，CNN）就是一种限于局部感受野来改造的神经网络（线性组合特殊化为局部区域的卷积操作，且增加了池化(Pooling)层），特别适合于文本、图像及视频类数据的深度学习。再比如，残差神经网络（Residual Neural Network，ResNet）有一种特殊的连接，可以把数据从某一隐层传至后面几层（通常是2到5层）。该网络的目的不是要找输入数据与输出数据之间的映射，而是致力于构建输入数据与输出数据+输入数据之间的映射函数。本质上，ResNet 是在学习映射函数的一阶差分（一阶导数），能够有效抑制优化过程中的梯度消失。类似地， DenseNet (CVPR 2017) 实质上是在学习映射函数的高阶差分，因此也能有效抑制梯度消失现象。同样地，其他的各种神经网络结构也很容易看懂的，比如 AutoEncoder，GAN，Variational GAN等。

(3) 神经网络的组合：一个多层的神经网络就是一个多次复合的函数。中间的任何一层的输出都可以看成为原始输入数据的一个特征。如图26所示，一个多层神经网络所表达的函数：可以看成前面的若干层网络所表达的函数（蓝色）与后面若干层网络所表达的函数（红色）的复合。因此，在任何的一个中间层，可以修改输出的特征向量、可以插入一个其他的神经网络（将该特征向量作为输入，或与其他网络的特征向量进行叠加、运算等）等等。如果将神经网络看成为积木，整个组合过程就像在“搭积木”。这样就可以发明和产生无穷无尽的网络结构（比如，并行网络、累加网络等等很多网络名称）。在实际应用中，需要根据问题本身的特点来合理设计网络的结构。具体哪种网络结构合理，有无最好，都是组要根据问题本身思考和试验的，主要是要看损失函数的误差以及在应用中的效果来决定的。这个我们在后面还会进一步讨论。

9.2. 如何调试深度神经网络？

一个深度神经网络所表达的函数具有成千上万个参数，为了让损失函数在训练数据上达到最小，就需要设计合理的网络来拟合这些数据。在优化的过程中，要保证迭代收敛也是必要的。

一般地，调试较大的深度神经网络所花费的时间和劳力比调试传统程序要多，而且要有耐心！因为如果最后的结果不好（损失函数很大或者不收敛），如果确认你的代码无bug，那么原因只有一个，就是你所调的网络还不够好(orz)！

在调试神经网络的过程中，有太多不确定的因素需要你去仔细思考并小心翼翼地去调试，而这些大部分都需要靠直觉、经验和少许运气来调试决定的，比如：

(1) 需要选取多大的神经网络（也就是选用什么样的拟合函数）？具体地，网络要多少层？每层多少节点？这个只能凭直觉或经验了。简单点的话，就套用现成的网络结构，或者再经过一些修改即可。从函数的自由度来看，网络的参数个数与数据大小不应相差太大。

(2) 初始化。对于高度非线性的函数的最优化，一个非常重要的因素就是如何挑选一个好的初始化？

(3) 在优化过程中，如何判断优化过程是否收敛？

(4) 是否发生了过拟合？

(5) … ….

以下有些简单的小经验分享下：

(1) 一定要可视化你的结果！这样有助于你在训练过程中发现问题。你应该明确的看到这些数据：损失函数的变化曲线、权重直方图、变量的梯度等。不能只看数值，一定要可视化！

(2) 网络不是越深越好！不要一上来就用VGG19, ResNet50等标准的大网络，可能你的问题只要几层就能解决问题。

(3) 先建立一个较小的网络来解决核心问题，然后一步一步扩展到全局问题。

(4) 先用小样本做训练，有了感觉后，再调试大的训练数据。

(5) 如果在几百次迭代后，迭代还没开始收敛，那么就要终止迭代，不要傻等了！要考虑修改你的网络了。

(6) 注意避免梯度消失或梯度爆炸。

(7) 另外，在互联网上还能找到许多网友们分（tu3）享（cao2）的实用调网络的经验，读者可自行去查找学习。

值得提醒的是，上述分享的各个经验没有绝对的对与错，须将它们当作经验去学习和使用即可。需要根据你自己的实际问题来设计和调试你的深度神经网络。

即便对于行家来说，调试较大的神经网络也是一项艰巨的任务。数百万个参数在一起决定的函数，一个微小的变化就能毁掉所有辛勤工作的成果。然而不进行调试以及可视化，一切就只能靠运气，最后可能浪费掉大把的青春岁月。

正因为这些原因，调试深度神经网络被认为是个不可解释的“黑箱子”，优化网络的过程成为“调参”，也被戏称为“炼丹”，是个需要丰富经验的“技术活”。

9.3. 深度学习开发工具

要学习和使用基于深度神经网络的深度学习，门槛并不高。你大不必从头开始自己搭建神经网络系统和实现优化算法。近几年来，很多大公司和科研机构都在研究自己的深度学习框架，且推出了不少深度学习开发平台（如图27），深度学习的开发框架和工具也越来越多，使得应用深度学习的入门门槛越来越低。使用好的开发工具，可让使用者减少底层开发的工作量，而将重点关注于深度学习应用逻辑的开发及模型的优化上，提高开发效率。

图27. 基于深度神经网络的深度学习的开发工具。（图片来自互联网）

这里简单介绍几款大家常用的深度学习开发工具包，基本都是开源的。

(1) TensorFlow, 由Google公司发布。支持多CPU及多GPU并行化运行，并支持CNN，RNN等主要的深度学习模型。Github社区人气最火的深度学习开源项目。

(2) Caffe，由加拿大Berkeley BVLC实验室发布。使用最广泛的深度学习工具之一，提供C++，Python，Matlab等语言接口。

(3) Torch，基于 Lua 脚本语言的工具，支持 iOS、 Android 等嵌入式平台。

(4) Theano，基于Python语言开发的深度学习开源仿真平台。

(5) Keras，基于Python语言开发的，底层库使用Theano或TensorFlow。其模块化特性非常适合刚入门的初学者快速实验并测试深度学习网络的性能，同时也开放提供对底层的修改。

关于这些开发工具包的使用，互联网上（包括Github）有非常丰富的教材和使用文档，读者有兴趣可以自行查阅学习。

9.4. 深度神经网络专用芯片

深度神经网络专用芯片（使用GPU+DNN的专用芯片）是一种特殊用途的处理器，它能够使得深度神经网络的训练更快，具有更高的性能和更低的功耗。DNN 专用芯片在性能和能源消耗方面的好处是显著的，DNN专用芯片的广泛使用还需要神经网络体系结构的标准化和对不同DNN框架的支持。国外的一些公司，包括Google、Nvidia、Intel等公司，已经开发和部署了DNN专用芯片，为基于DNN的应用程序提供了极高的性能。国内也有不少公司（如寒武纪、阿里巴巴等）在从事DNN专用芯片的研发，也已经达到国际前沿水平。

十、 深度神经网络的能力与局限

深度学习真有智能吗？遗憾的是，没有！

10.1. 基于深度神经网络的深度学习的本质再回顾

在本文，笔者从函数逼近论的角度已详细剖析了基于深度神经网络的深度学习，归纳为以下4个基本点：

(1) 深度神经网络（DNN）是一个复合函数。对于任何单变量函数，只要神经元足够多，神经网络函数就能任意逼近它；对于任何多变量函数，一定可以被多个单变量函数的复合来逼近，因此就能被深度神经网络函数进行逼近；上述两点为神经网络函数的表达能力提供了理论基础；

(2) 基于DNN的深度学习是个数据拟合（最小二乘回归）的过程；

(3) 拟合过程是在学习基函数；

(4) 多层映射是在做多次变换（或参数化）。

因此，基于DNN的深度学习是可以很清楚被理解的！具体的应用过程中，选多少层、选多少基的问题在逼近论中就是没有很好的解决方案，这是逼近论中就存在的问题，并不是深度网络带来的问题！

从数学本质来看，深度学习是在做最小二乘回归；其他的机器学习方法也是基于最小二乘回归的其他回归方法或者统计方法。

从应用性来看，还有以下一些对基于深度神经网络的深度学习的本质的说明：

(1) 基于DNN的深度学习实际上在做拟合和统计，网络结构设计需要靠直觉、技巧和经验以及运气；

(2) 激活函数和损失函数的选择也很重要；

(3) DNN的层数、各层的神经元个数决定了该函数的参数；一般的DNN都具有非常多的参数；

(4) DNN适合拟合大规模数据；对小规模数据，不建议用DNN；

(5) 任何一个中间隐层的输出向量都可以作为输入数据的特征（在该维数上的），也是输入数据的参数化；

(6) DNN可以任意拼装、组合成各种复杂的网络结构；

(7) 大部分论文中的DNN结果都可能是过拟合；因此，很容易出现误判的情况（输入的轻微变化，比如给图片加少量噪声，结果就相差很大），容易犯大错；

(8) DNN是以成败论英雄的，需要在实际应用中好才是真的好，而这个永远不知道。

需要再提一下的是，本文所讨论的基于DNN的深度学习只是深度学习的一种方法而已。还有其他的深度学习，比如南京大学周志华老师团队所提的深度森林等方法。

10.2. 深度神经网络具有“智能”吗？

从上面的剖析来看，基于DNN的深度学习实质上就是对样本数据集的拟合而已！显而易见，它仅仅是一个由数据驱动的产生的拟合器或分类器，根本不是一个“认知系统”！我们并没有看出来它有任何“智能”（即对数据所呈现的规律、知识的理解）的存在！对人工神经网络的研究可能仍然是几十年前的进展，只不过现在网络的规模变大了（数据大了，优化强了）而已！

从逼近论的角度来看，如果数据足够大，多到足以（稠密）覆盖整个目标函数，那么简单的最近邻查找或者局部线性插值的性能就足够好了。此时，笔者猜测，深度学习的性能与最近邻查找的性能可能相差无几！

举个例子，市面上出现了许多种类的所谓的“智能机器人”，声称可以与人进行自由对话。建议读者去测试一下这些对话机器人，你们就会发现，这些机器人的问答系统基本没有理解（只有少数有少量简单的理解）。如果对于在其数据库中存在的问题或类似的问题，机器人能够回答得比较合理；如果遇上需要逻辑推理的问题，这些机器人基本就答非所问，或者王顾左右而言他，甚至开始“卖萌”了。有空去逗逗这些对话机器人也是蛮有意思的事。

对于自动翻译等机器人，只要有足够的两种语言的对应词条或句子（比如有些公司的词库数据库非常庞大，达到亿级），就能“翻译”（拟合）得还不错，达到一定的实用水准。但从本质上来讲，这些翻译算法并没有真正理解语言本身！

关于深度学习，我们要有清醒的认识：

 深度学习模型需要大量的训练数据，才能有较好的效果；因为这些学习模型都在做数据拟合或回归，或者是在做统计；

 实际问题中，往往会遇到小样本问题，采用传统的简单的机器学习方法，则可以很好地解决了，没必要非得用复杂的深度学习方法；

 神经网络看起来来源于人脑神经元的启发，但绝不是人脑的模拟！它只是一个复合函数！举个例子，给一个三四岁的小孩看过几只猫之后，他就能识别其他的猫。也就是说，人类的学习过程往往不需要大规模的训练数据，而现在的深度神经网络的学习方法显然不是对人脑的模拟。

这几年各种媒体的大量夸张的报道和宣传（即使是战胜人类的围棋算法AlphaGo，也并不是真正的人工智能，而仅仅是机器在一定的游戏规则下的策略计算能力），极度夸大了人工智能的进展，让很多大众误认为“强人工智能”已经来临，甚至产生不必要的恐慌。

事实上，现在的人工智能的进展仍然很小，正如清华大学人工智能研究院院长张钹院士在2018年全球人工智能与机器人峰会（CCF-GAIR）上的报告上所指出的：“人工智能刚刚起步，离真正的人工智能还很遥远… 我们必须走向具有理解的人工智能，这才是真正的人工智能。”

10.3. 深度学习在工业界的应用

虽然近几年发展起来的基于DNN的深度学习并未产生真正的智能。但由于现在有大量的数据，基于数据驱动的深度学习方法可以在很多领域确实得到了落地的应用。特别是在计算机视觉领域，比如人脸识别、图像分割与识别等，该领域做了很多年的一些问题的研究工作，瞬间就被深度学习所击败！深度学习取得了巨大的成功！因此，我们仍能使用深度学习解决不少问题。

近几年，催生了大量的人工智能公司，分布在安防、医疗、金融、智能机器人、自动驾驶、智能芯片、智能家居等领域；各高校也纷纷构建了人工智能研究院或大数据学院等；各学会成立了人工智能相关的专业委员会；国家也纷纷出台了有关人工智能的政策与文件，包括《新一代人工智能发展规划》，鼓励人工智能方面的人才培养（从娃娃抓起）和产业落地。在科研领域，大量的研究工作者和学生都涌进到人工智能领域，在一些人工智能或计算机视觉领域的会议的投稿量迅速增加，参加会议的人数达到历史新高。

但残酷的事实是，绝大部分的人工智能公司都是“伪人工智能”，他们或者仅仅在做着数据标注的工作，因为标注数据的多少决定着拟合函数的“智能”！另外，已经有些公司因未能找到合适的盈利模式而倒闭。前几年对深度学习及智能的期望并未达到人们及投资者的预期目标。今年年初，李开复曾指出：“2018年是AI泡沫破裂之年”。

从两年前人工智能热潮的爆发，到现在热潮逐渐退去，人们也越来越趋于冷静来认识人工智能，对其研究与应用逐渐趋于务实。笔者也希望人工智能能真正快速发展，让人类的生活变得越来越美好！

10.4. 深度学习与人工智能的关系

1956年，几个计算机科学家相聚在达特茅斯会议，提出了“人工智能”（Artificial Intelligence， AI）的概念，梦想着用计算机来构造复杂的、拥有与人类智慧同样本质特性的机器。人工智能研究领域范围很广，包括专家系统、机器学习、进化计算、模糊逻辑、计算机视觉、自然语言处理、推荐系统等，如图27 （左）。

机器学习（Machine Learning, ML）是一种实现人工智能的方法。其基本做法是使用算法来解析数据、从中学习，然后对真实世界中的事件做出决策和预测。与传统的为解决特定任务、硬编码的软件程序不同，机器学习是用大量的数据来“训练”，通过各种算法从数据中学习如何完成任务。传统的机器学习算法包括决策树、聚类、贝叶斯分类、支持向量机、EM、Adaboost等等。从学习方法上来分，机器学习算法可以分为监督学习（如分类问题）、无监督学习（如聚类问题）、半监督学习、集成学习、深度学习和强化学习等。

深度学习（Deep Learning, DL）是一种实现机器学习的技术，是解决特征表达的一种学习过程。现在常指利用深度神经网络的深度学习。在很早就有人提过，但由于当时训练数据量不足、计算能力落后，因此深度学习的效果不尽如人意；直到近几年，深度学习才较好地实现了各种任务。事实上，除了基于深度神经网络的深度学习，还有其他形式（比如深度森林）的深度学习方法。

因此，机器学习是一种实现人工智能的方法，深度学习是一种实现机器学习的技术，而深度神经网络是实现深度学习的一种具体的实现工具，如图28（右）所示。简而言之，从范畴来讲，他们的关系如下：

深度神经网络 < 深度学习 < 机器学习 < 人工智能

图28. 左：人工智能的研究范畴；右：人工智能、机器学习和深度学习的关系。

（图片来自互联网）

但残酷的事实是，近几年流行的基于深度神经网络的深度学习仅仅是一个数据拟合器，并不存在着分析与理解等智能的能力。现有的技术和方法离真正的人工智能还非常遥远！

十一、 三维几何数据

在计算机图形学中，我们研究的对象是三维（3D）形状对象，即虚拟空间中的数字化的物理实体。表达3D对象的3D几何数据是继声音、图像、视频之后的第四代数字可视媒体（如图29），已逐渐具有越来越广泛的应用。

图29. 四代可视媒体的发展：声音、图像、视频、3D几何。

11.1. 3D 数据的重要性

地球上的人及所有动物都有两只眼睛，每只眼睛类似于一台照相机，看到的是场景在视网膜（成像平面）上的投影图像，如图30（左）。两只眼睛位置不同，就产生对同一场景的视差，从而在大脑生成了场景的立体和3D信息（双目立体视觉原理），如图30（右）。

图30. 左：单眼看到的是图像，为三维世界在成像平面上的投影影像；右：人类及动物的两只眼睛通过双眼的视差产生了对场景物体的立体和三维的信息。（图片来自于互联网）

因此，人类及动物的视觉感知系统是具有立体的特性。世界是三维的，3D模型提供了世界及所有物体的全方位、全息的表达，能提供比二维图像更丰富、更全面的空间信息（比如猎鹰能在几公里外判断草地上一只兔子的远近和方位，以便做出下一步的飞行行为）。而单眼（如果以前存在的话）动物则因无法分辨物体的远近，而无情地被自然法则所淘汰。

计算机视觉通过对图像的理解和分析已经能够解决非常多的任务（比如物体检测、分割、识别、检索等）。但在很多实际应用中，如果涉及到空间关系分析以及与3D环境和物体的理解、交互和创造，则光靠2D图像信息是不够的，此时必须依赖场景的3D信息，比如数字城市中的空间关系分析、机器人抓取3D物体、虚拟和增强现实、物联网数据的空间关联等，如图31所示。在这些应用中，仅仅靠图像信息是无法很快完成各项任务的。

图31. 三维数据在很多实际应用场景中是必不可少的信息。

11.2. 3D数据集

随着3D物体的扫描与采集手段的日益增多（特别是近几年快速发展的深度相机，比如Microsoft Kinect、Intel RealSense、Google Project Tango、Apple Primesense、Asus Xtion等）、未来可采集3D信息的移动终端（去年iPhoneX上已有深度相机）的普及、以及互联网上3D模型的创造与分享，3D数据（包括RGB-D数据）将日益丰富。

至今，已有许多研究机构构建并公布了一些3D数据集，比如：

ShapeNet数据集：包含了约300多万个3D模型（3000多类物体），每个模型有语义注释。这是当前最大的一个三维模型数据集；其子集ShapeNetCore具有一些手工的标注；

ModelNet数据集：包含了12多个3D模型（662类），包含两个子集Model10和ModelNet40；

ShapeGoogle数据集：包含了近600个非刚性3D模型，用于检索测试；

SHREC数据集：包含了上千个非刚性3D模型，包括不少人的模型和合成数据集；

Watch-N-Patch数据集：由Cornell大学和Stanford大学公布，主要是人体3D模型数据。

还有一些高校和研究机构公开了一些RGB-D数据集，包括Princeton大学（415个室内场景，990万个标记图像），纽约大学（464个室内场景），Cornell大学（24个办公室场景，28个居家室内场景），Washington大学（14个室内场景）等。

另外，瑞士苏黎世大学发布了一个使用LiDAR（激光3D扫描）扫描的40个办公室场景的高精度3D场景模型数据集。

11.3. 3D形状描述子

类似于2D图像，人们也需要对3D模型数据进行分类与识别、分割与建模、匹配与检索等。完成这些任务的关键就是如何定义和计算3D模型的形状描述子（Shape descriptors）或特征（Features）。

至今，人们已提出了各种基于全局和局部的形状几何属性的空间分布或统计信息的3D形状描述子（如图32所示）。这些形状描述子都是针对某种特定的应用或某些特定的3D模型类型而提出的，同时满足所有应用及所有模型类型的3D形状描述子还没有。在实际应用中，应根据物体类型和具体应用来选择合适的形状描述子（特征选择）。比如，笔者如下论文使用稀疏选择的方法来选择合适的形状描述子用于3D 形状分割。

[11-1] Ruizhen Hu, Lubin Fan, Ligang Liu. Co-Segmentation of 3D Shapes via Subspace Clustering. Computer Graphics Forum (Proc. Symposium on Geometry Processing), 31(5): 1703-1713, 2012.

11.4. 3D几何数据的深度学习的挑战

随着3D数据（包括单个模型以及场景模型）的日益流行和丰富，如何利用上述丰富的3D数据集来完成分析和处理3D形状数据，已成为研究工作者及产业工作者的关注焦点和研究热点。因此，3D形状的特征提取方法也逐步从上述的人工定义特征方法到基于深度学习的特征学习方法的发展。

相对于图像与视频处理，3D几何数据的深度学习方法在近几年才开始有了一些工作和进展，但仍面临着一些挑战。

(1) 3D数据集较小

相比于ImageNet等千万级数据量的2D图像数据集，现在的3D模型数据集的数量很少，仍未达到“大数据”的规模。另外，3D数据的标注也是较为困难的。

(2) 3D数据是非结构化的

图像和视频都是结构化数据，是线性结构的，可以表达为一个向量或矩阵。但3D模型数据是非结构化的（如图33所示），每个顶点的邻域数是非固定的，从拓扑上看是一个图（Graph），无法直接使用深度神经网络。

(3) 3D数据的复杂性

相对于图像和视频，3D模型还有其他一些复杂性，包括：

(a) 正向姿态性：图像基本都是正向拍摄的，但是3D模型的姿态可以是任意的，如何消除姿态的影响仍有挑战。为了方便，一般会预先将数据集中的模型统一正朝向；

(b) 表达不统一：图像就是一个矩阵结构，表达非常统一；但是3D模型有不同的表达方式，比如点云、网格、体素、隐函数、CSG树等（如图34），使得需要对不同表达的数据进行不同的处理；

图32. 各种人工3D形状描述子。

图33. 二维图像与三维网格的数据结构的区别。

图34. 三维几何数据的不同表达。

十二、 智能图形处理：三维数据的深度学习

3D图形作为一种新型的可视媒体数据类型，同样可以利用人工智能和深度学习的方法来进行分析和处理，融合大数据、并行计算及人工智能技术的最新进展以提高计算机图形学算法及系统易用性及效率，称为智能图形处理。

近几年，已有越来越多的研究工作将机器学习和深度学习的方法应用于3D数据。本节仅就3D形状描述子方面做一个简略的介绍。

应用深度学习来自动抽取3D形状特征主要有以下3种方法：第一种，基于传统的人工特征（维数一致了）来进行更抽象的形状特征的学习和抽取；这种方法是非端到端的；第二种，将3D数据转化为规整结构数据（欧氏区域），然后再应用深度学习方法抽取形状特征，称为显式方法；第三种，将深度神经网络改造成能够处理非欧氏区域数据，称为隐式方法。下面分别从方法论上进行简单介绍。

12.1. 基于人工特征的特征学习方法

由于传统卷积无法直接作用于3D形状，早期的方法避开了直接以3D形状作为输入的训练，而是先从3D模型中提取一些人工特征（称为低级特征，如图32），再把这些特征输入到神经网络中进行学习，获得新的抽象特征（称为高级特征），如图35所示。

图35. 基于人工特征的特征学习方法。

[12-1] Zhige Xie, Kai Xu, Ligang Liu, Yueshan Xiong. 3D Shape Segmentation and Labeling via Extreme Learning Machine. Computer Graphics Forum (Proc. SGP), 33(5): 85-95, 2014.

[12-2] Kan Guo, Dongqing Zou, and Xiaowu Chen. 3D mesh labeling via deep convolutional neural networks. ACM Transactions on Graphics, 35, 1, 2015.

[12-3] Zhenyu Shu, Chengwu Qi, Shiqing Xin, Chao Hu, Li Wang, Yu Zhang, Ligang Liu. Unsupervised 3D Shape Segmentation and Co-segmentation via Deep Learning. Computer Aided Geometric Design (Proc. GMP), 43: 39-52, 2016.

人工定义的特征很大程度上取决于人的经验。因此，基于人工特征的特征学习方法并不是端到端的深度学习方法。另外，各种人工特征向量的排列也会改变特征矩阵及其卷积后的结果，对结果产生如何的影响也不清楚。

12.2. 非本征方法

这种方法是将3D数据进行合适的变换，将其变换到一个欧氏空间的规则区域，以便适用于深度神经网络。此类方法改变了3D网格模型的形态，本质上也改变了数据分布空间，是为了适应传统CNN或MLP对拓扑的要求而提出的折衷解决方法，因此成为基于欧氏空间的学习方法或非本征方法，如图36所示。

图36. 非本征深度学习方法。

变换的区域和方法主要有以下几种。

(1) 图像区域。最简单的方法就是将3D模型数据投影到平面形成图像。

(a) 多视图图像：将3D模型往多个视角方向投影生成多幅图像，比如[12-4, 12-5]；

(b) 全景图像：将3D模型往平面投影生成一幅全景图，比如[12-6]；

(2) 体素区域。

(a) 类比于图像中的像素，将3D形状看作三维体素网格的0，1分布，比如[12-9, 12-10， 12-11]。由于体素的个数是三次方增长，因此，体素的分辨率无法太大，一般连128x128x128的分辨率做起来都很困难。

(b) 只将模型表面用体素来表达，而省去内部体素的存储，并且利用八叉树的形式来存储，可以有效地提高体素的分辨率及模型的表达精度，比如[12-12]。

(3) 基元组合。三维形状还可以表示成一些基本单元的组合，如矩形块、圆柱、圆锥、球等，然后利用网络来学习这些基本体块的参数，比如[12-13, 12-14]。

(4) 点云。直接将3D数据看成点的集合。将每个点看作一个神经元节点，节点包含点的坐标或法向等信息，然后利用深度神经网络提取点的特征。这里要克服点及点邻域的顺序无关性等。比如[12-14, 12-15, 12-16, 12-18]。

[12-4] Su, H. and S. Maji, et al. (2015). Multi-view convolutional neural networks for 3D shape recognition. ICCV.

[12-5] Xie, Z. and K. Xu, et al. (2015). Projective Feature Learning for 3D Shapes with Multi‐View Depth Images. CGF.

[12-6] Shi, B. and S. Bai, et al. (2015). Deeppano: Deep panoramic representation for 3‐D shape recognition. IEEE Signal Processing Letters.

[12-7] Sinha, A., Bai, J., Ramani, K., et al. (2016). Deep learning 3D shape surfaces using geometry images. ECCV.

[12-8] Maron, H. and Galun, M. (2017). Convolutional Neural Networks on Surfaces via Seamless Toric Covers. SIGGRAPH.

[12-9] Qi, C. R. and H. Su, et al. (2016). Volumetric and multi-view cnns for object classification on 3D data. CVPR.

[12-10] Brock, A. and T. Lim, et al. (2016). Generative and discriminative voxel modeling with convolutional neural networks. NIPS.

[12-11] Wu, Z., and Song, S. et al. (2015). 3d shapenets: a deep representation for volumetric shapes. CVPR.

[12-12] Wang, P. S. and Liu, Y. et al. (2017). O-cnn: octree-based convolutional neural networks for 3d shape analysis. TOG.

[12-13] J. Li, K. Xu, et al. Grass: Generative recrusive autoencoders for shape structures. ACM Trans. on Graph., 36(4), 2017.

[12-14] S. Tulsiani et al. Learning shape abstraction by assembling volumetric primitives. CVPR, 2017.

[12-15] Garcia-Garcia, A. and Gomez-Donoso, F. et al. (2016). PointNet: A 3D Convolutional Neural Network for real-time object class recognition. IJCNN.

[12-16] Qi, C. R. and H. Su, et al. (2017). PointNet: Deep learning on point sets for 3D classification and segmentation. CVPR.

[12-17] Qi, C. R. and Yi, L. et al. (2017). PointNet++: Deep Hierarchical Feature Learning on Point Sets in a Metric Space. CVPR.

[12-18] Yangyan Li, Rui Bu, Mingchao Sun, and Baoquan Chen (2018). PointCNN. arXiv:1801.07791.

12.3. 本征方法

本征方法直接将三维形状看成二维流形（Manifold）或由点组成的图（Graph），顶点之间的距离不再是欧氏距离，然后直接将卷积定义在这样的数据结构上，称为非欧氏空间学习的方法或本征方法，如图37。两种典型的网络为测地卷积网络（Geodesic CNN, GCNN）和图卷积网络（Graph-based CNN），如图38，可参考[12-19, 12-20, 12-21, 12-22]。

[12-19] Masci, J. and Boscaini, D. et al. (2015). Geodesic convolutional neural networks on Riemannian manifolds. ICCV.

[12-20] Monti, F. and Boscaini, D., Masci. (2016). Geometric deep learning on graphs and manifolds using mixture model CNNs. arXiv preprint arXiv:1611.08402.

[12-21] Boscaini, D. and Masci, J. et al. (2016). Learning shape correspondence with anisotropic convolutional neural networks. NIPS.

[12-22] Yi, L. and Su, H. et al. (2017). Syncspeccnn: Synchronized spectral CNN for 3d shape segmentation. CVPR.

图37. 本征深度学习方法。

图38. 本征深度学习的具体方法。左：测地卷积；右：图卷积网络。

12.4. 端到端的生成模型

在上面的工作中，深度学习用于解决3D形状的识别、分割、匹配和对应等问题。近年来，越来越多的工作致力于3D 模型的构建和生成（大部分都是使用生成-对抗网络GAN）。由于可以自动生成大量的3D模型，对于扩充3D模型数据集具有重要的意义，非常值得大家关注。

这里简略介绍一下端到端的3D模型生成的一些工作。所谓端到端的生成模型，就是输入是简单易获得的，输出是三维模型，中间无需其他操作。例如，可以从输入的一张照片输出三维体素模型[12-23, 12-24]、点云模型[12-25]、或者网格模型及其参数化[12-26]；[12-27]利用级联的图卷积网络由粗到精逐渐细化网格模型；[12-28]由手绘草图生成参数化的夸张人脸模型。

[12-23] J. Wu et al. Learning a probabilistic latent space of object shapes via 3D generative-adversarial modeling. Advances in Neural Information Processing Systems, 82-90, 2016.

[12-24] J. Li et al. Grass: Generative recursive autoencoders for shape structures. Siggraph 2017.

[12-25] H. Fan et al. A point set generation network for 3D object reconstruction from a single image. CVPR 2017.

[12-26] T. Groueix et al. AltasNet: A papier approach to learning 3D surface generation. arXiv: 1802.05384, 2018.

[12-27] N. Wang et al. Pixel2Mesh: Generating 3D mesh models form single RGB iamges. arXiv: 1804.01654.

[12-28] X. Han et al. DeepSketch2Face: A deep learning based sketching systems for 3D face and caricature modeling. Siggraph 2017.

【后记】

此文分享了笔者对基于深度神经网络的深度学习的理解，从逼近论的角度深入浅出地理解了深度学习的原理，了解了整个调试深度网络的“炼丹”过程，是个需要丰富经验的“技术活”。机器学习还有很多其他重要的方法，比如非监督学习和强化学习等，笔者就不一一进行介绍了。

从本文的分析可知，基于深度神经网络的深度学习背后的运行原理主要基于数据驱动的函数拟合，采用的是“经验主义”的实用方法（比如数学中的最小二乘方法及统计学中的统计回归方法等）；它离真正的人工智能，即能通过图灵测试（Turing Testing）的智能机器还很远。从数学本质上来看，现在基于数据的深度学习方法实质上只有“记忆”能力，并没有对问题的“理解”能力，更没有人们所期待的“人类智能”。

从研究的方法论来看，对于要研究的对象（信息或数据），如果在不同的空间（角度）来观察会有对该对象有不同的理解和认知（比如信号处理中，在时域和频域的变换下的Fourier分析），即对象在该空间中所表现的“特征”。因此，在不同的空间进行变换就成为关键的步骤之一。在以往的研究中，需要研究者对对象有深刻的理解来对信息进行特定的变换（即在特定的基函数的变换下）。而深度神经网络实现了端到端的变换，通过多层（深度）复合的变换（多次变换）自动提取了在不同空间的“特征”，即根据数据本身自适应“学习”基函数。这是深度神经网络的巨大优势之一。另外，深度神经网络的另一个巨大优势就是可以通过数量众多的小函数（激活函数）的线性变换及复合来逼近非常复杂的函数，解决了人工设计基函数的困难。因此，基于深度神经网络的深度学习具有非常广泛的实际应用。另外值得一提的是，从Fourier变换到小波变换的发展来看，可以将神经网络中的激活函数变为特殊的局部基函数，使得比现有的全局激活函数适用于更广泛的函数（比如瞬时信号函数），将来再抽时间来详细分析和阐述。

从计算数学领域来看，神经网络提供了可以构建任意维度之间的映射和函数，这是传统逼近论所无法做到的。这使得人们研究的数据维度和数据类型极大的丰富了，而不只是对1维和2维等低维数据进行分析和处理。这将是一个非常重要的方法论，将对科学领域的研究方法、手段和进展也具有极大的促进和推动作用。有理由相信，深度学习方法（或人工智能方法）将会被当作计算数学、应用科学的计算工具或科研工具，催生新的科研范式，被越来越多地用来解决一些计算数学和其他科学领域中的问题。

从方法论来看，也可以从统计学的角度来看深度神经网络，将深度神经网络来拟合数据的分布（分布函数），比如生成网络和GAN等，也是近期研究的热点。在本文中对此方法论没有进行展开。

图39. Gartner 2018人工智能技术成熟度曲线。（图片来源于互联网）

五年前（2013年4月），《麻省理工学院技术评论》杂志将深度学习列为2013年十大突破性技术（Breakthrough Technology）之首。经过前几年的高速发展，根据Gartner在7月刚发布的2018人工智能技术成熟度曲线（如图39），深度神经网络及深度学习已从前几年的爬坡阶段到达顶部。未来，相信人们将会更冷静地来看待及发展相关的技术和应用。

最近，有人提出“可微编程（Differentiable Programming）”的概念，就是将神经网络当成一种语言（而不是一个简单的机器学习的方法），来描述我们客观世界的规律。甚至Yann LeCun曾在Facebook的文章中说道：“Deep Learning Is Dead. Long Live Differentiable Programming!”（深度学习已死，可微编程永生）这个概念的提出又将神经网络提高了一个层次。

本文完稿核对时，笔者发现文中有些数学符号（比如等）存在着重复定义与使用，但根据上下文并不影响阅读和理解，因此笔者就不花时间去修正了，在此说明下。

再次声明下，笔者的主要研究领域为计算机图形学，而非人工智能领域，因此本文仅仅为笔者从外行的角度对基于深度神经网络的深度学习的粗浅理解，而非人工智能领域对深度神经网络和深度学习的权威解释。笔者对其中的有些内容的理解是有限的，甚至是有误的。因此，该文仅供读者参考，不作为专业资料！如有不当之处，还请读者指正！

【致谢】

笔者在学习深度神经网络及深度学习的过程中，阅读了许多相关的书籍和论文（比如周志华老师的《机器学习》一书和李宏毅老师的课件等）以及微信订阅号（比如《SigAI》、《人工智能学家》、《深度学习大讲堂》、《老顾谈几何》等），在此表示感谢。也感谢舒振宇、徐凯、韩晓光、沈小勇、胡瑞珍等同行、以及笔者实验室的同事（张举勇、傅孝明、杨周旺等）和学生（陈明佳、方清、杜冬、石磊、欧阳文清、刘中远等），与他们的交流和讨论也让笔者受益匪浅。

最后，希望您能从本文受益。祝您健康、快乐、成功！

刘利刚

中国科学技术大学图形与几何计算实验室(http://gcl.ustc.edu.cn)

个人主页：http://staff.ustc.edu.cn/~lgliu

电子邮箱：lgliu@ustc.edu.cn

2018年8月8日

输出网络参数和网络结构

Tue, 12 Dec 2023 00:00:00 GMT

输出网络参数和网络结构

1、输出网络参数

print("\n\nprint the each layer's name(GAB)")
for name in G_AB.state_dict():
  print(name)
print("\n\nprint the name and the size of layers")
for name,parameters in G_AB.named_parameters():
  print(name,";",parameters.size())
print("\n\nsave the parameters")
for layer in ['model.1.freq','model.1.theta','model.1.sigma','model.1.psi','model.1.x','model.1.y','model.1.weight']:
  print("\n",layer)
  print(G_AB.state_dict()[layer])
  G_AB.state_dict()[layer].cpu().detach().numpy().tofile(layer[8:]+'.rsf@')

2、输出网络结构

from torchinfo import summary
summary(G_AB,input_size=(16,1,256,256))

离散余弦变换DCT

Sun, 12 Nov 2023 00:00:00 GMT

离散余弦变换DCT

1、离散余弦变换

离散余弦变换（discrete cosine transform, DCT）是与傅里叶变换相关的一种变换，类似于离散傅里叶变换，但是只使用实数。离散余弦变换相当于一个长度大概是它两倍的离散傅里叶变换，这个离散傅里叶变换是对一个实偶函数进行的（因为一个实偶函数的傅里叶变换仍然是一个实偶函数），在有些变形里面需要将输入或者输出的位置移动半个单位。这是由于离散余弦变换具有很强的"能量集中"特性：大多数的自然信号（包括声音和图像）的能量都集中在离散余弦变换后的低频部分，而且当信号具有接近马尔可夫过程的统计特性时，离散余弦变换的去相关性接近于K-L变换（Karhunen-Loève变换——它具有最优的去相关性）的性能。

一个401*3001炮集利用DCT实现数据重构，J(450:end,:) = 0; 数据量（3001->450;15%）

Reference

【1】离散余弦变换 - 维基百科，自由的百科全书 (wikipedia.org)

VIM基本操作

Tue, 12 Sep 2023 00:00:00 GMT

VIM基本操作

跳转到指定行：

1. 88G （命令模式）
2. :88  (末行模式)

跳转文件首：

gg （命令模式）

跳转文件尾：

G（命令模式）

自动格式化程序：

gg=G（命令模式）

大括号对应：

% （命令模式）

光标移至行首：

0 （命令模式）执行结束，工作模式不变。

光标移至行尾：

$ （命令模式）执行结束，工作模式不变。

删除单个字符：

x （命令模式）执行结束，工作模式不变。

替换单个字符：

将待替换的字符用光标选中， r （命令模式），再按欲替换的字符

删除一个单词：

dw（命令模式）光标置于单词的首字母进行操作。

删除光标至行尾：

D 或者 d$（命令模式）

删除光标至行首：

d0 （命令模式）

删除指定区域：

按 V （命令模式）切换为 “可视模式”，使用 hjkl挪移光标来选中待删除区域。  按 d 删除该区域数据。

删除指定1行：

在光标所在行，按 dd （命令模式）

删除指定N行：

在光标所待删除首行，按 Ndd （命令模式）

复制一行：

yy

粘贴： p：向后、P：向前。

查找： 1. 找设想内容：

    命令模式下， 按 “/” 输入欲搜索关键字，回车。使用 n 检索下一个。

2. 找 看到的内容：

    命令模式下，将光标置于单词任意一个字符上，按 “*”/ “#”

单行替换：

将光标置于待替换行上， 进入末行模式，输入 :s /原数据/新数据

通篇替换：

末行模式， :%s /原数据/新数据/g   g:不加，只替换每行首个。   sed

指定行的替换：

末行模式， :起始行号，终止行号s /原数据/新数据/g   g:不加，只替换每行首个。

    :29,35s /printf/println/g

撤销、反撤销：

u、ctrl+r（命令模式）

分屏： sp：横屏分。 Ctrl+ww 切换。

vsp：竖屏分。Ctrl+ww 切换。

跳转至 man 手册：

将光标置于待查看函数单词上，使用 K（命令模式）跳转。 指定卷， nK

查看宏定义：

将光标置于待查看宏定义单词上，使用 [d 查看定义语句。

在末行模式执行shell命令：

:!命令        :! ls -l

C语言索引遍历探究

Tue, 12 Sep 2023 00:00:00 GMT

C语言索引遍历探究

# include "alloc_function.h"
# include <stdio.h>
# include <stdlib.h>
# include <string.h>
#include <limits.h>
# define TIMES 21

int main()
{
    clock_t t0, t1, t2;
    float *arr1d;
    float ***arr3d;
    float time_r;
    float sum;
    float *pointer;
    size_t N1=2000;
    size_t N2=1000;
    size_t N3=50;
    arr1d = alloc1float(N1*N2*N3);
    arr3d = alloc3float(N1,N2,N3);
    size_t N = N1*N2*N3;
    printf("N=%ld\n", N);
    printf("size_t=[0,%u]\n", UINT_MAX);
    printf("int   =[%d,%d]\n", INT_MIN, INT_MAX);

    // 1D array
    time_r=0.0f;
    for(size_t time=0; time<TIMES; time++){
        t0 = clock();
        sum = 0.0f;
        for(size_t i=0; i<N; i++)
        {
            arr1d[i] = 1e-6f;
            sum += arr1d[i];
        }
        t1 = clock();
        if (time>0)
        time_r += (float)(t1-t0)/1000000.0;
    }
    printf("1D array: %f \t %f\n", time_r,sum);

    // 1D array pointer
    time_r=0.0f;
    for(size_t time=0; time<TIMES; time++){
        t0 = clock();
        sum = 0.0f;
        for(pointer = arr1d; pointer<arr1d+N; pointer++)
        {
            *pointer = 1e-6f;
            sum += *pointer;
        }
        t1 = clock();
        if (time>0)
        time_r += (float)(t1-t0)/1000000.0;
    }
    printf("1D array pointer: %f \t %f \n", time_r, sum);

    // 3D array Nonequential read
    time_r=0.0f;
    for(size_t time=0; time<TIMES; time++){
        t0 = clock();
        sum = 0.0f;

        for(size_t i=0; i<N1; i++)
        {
            for(size_t j=0; j<N2; j++)
            {
                for(size_t k=0; k<N3; k++){
                    arr3d[k][j][i] = 1e-6f;
                    sum += arr3d[k][j][i];
                }
            }
        }
        t1 = clock();
        if (time>0)
        time_r += (float)(t1-t0)/1000000.0;
    }
    printf("3D array Nonequential: %f \t %f\n", time_r, sum);

    // 3D array Sequential read
    time_r=0.0f;
    for(size_t time=0; time<TIMES; time++){
        t0 = clock();
        sum = 0.0f;

        for(size_t k=0; k<N3; k++)
        {
            for(size_t j=0; j<N2; j++)
            {
                for(size_t i=0; i<N1; i++){
                    arr3d[k][j][i] = 1e-6f;
                    sum += arr3d[k][j][i];
                }
            }
        }
        t1 = clock();
        if (time>0)
        time_r += (float)(t1-t0)/1000000.0;
    }
     printf("3D array Sequential: %f \t %f\n", time_r, sum);

}

运行结果

使用指针遍历，要比索引块快%5；

非顺序读写耗时约为顺序读写的2.5倍；

多维数组，没有一维数组快。

实现代码

C语言中的int main(int argc,char argv[]的含义和用法

Tue, 12 Sep 2023 00:00:00 GMT

C语言中的int main(int argc,char* argv[]的含义和用法

1、基本概念

　　argc,argv 用命令行编译程序时有用。

　　主函数main中变量(int argc,char *argv[ ])的含义，有些编译器允许将main()的返回类型声明为void，这已不再是合法的C++

　　main(int argc, char *argv[ ], char **env) 才是UNIX和Linux中的标准写法。

　　　　argc: 整数,用来统计你运行程序时送给main函数的命令行参数的个数

argv[ ]: 指针数组，用来存放指向你的字符串参数的指针，每一个元素指向一个参数

　　　　argv[0] 指向程序运行的全路径名

　　　　argv[1] 指向在DOS命令行中执行程序名后的第一个字符串

　　　　argv[2] 指向执行程序名后的第二个字符串

　　　　...

　　　　argv[argc]为NULL。

　　　　env：字符串数组。env[ ]的每一个元素都包含ENVVAR=value形式的字符串。其中ENVVAR为环境变量，value 为ENVVAR的对应值。

　　argc, argv,env是在main( )函数之前被赋值的，编译器生成的可执行文件，main( )不是真正的入口点，而是一个标准的函数,这个函数名与具体的操作系统有关。

2、具体用法

　　经典例子

　　对于理解argv[ ]函数很管用：

/* xx.c */
#include<stdio.h>
int main(int argc,char *argv[])
{
    int i;
    if(argc==1)
        printf("only get the program!\n");
    if(argc>2)
    for(i=1;i<argc;i++)
           printf("inputfile[%d]:%s\n",i+1,argv[i]);
    return 0;
}

　　编译运行结果如下：

ubuntu@ubuntu:~/DATA/others$ gcc xx.c -o lgl
ubuntu@ubuntu:~/DATA/others$ ./lgl
only get the program!
ubuntu@ubuntu:~/DATA/others$ ./lgl xx 123 zls2
inputfile[2]:xx
inputfile[3]:123
inputfile[4]:zls2
ubuntu@ubuntu:~/DATA/others$

　　main(int argc, char* argv[ ])，其中argc是指变量的个数，本例中即指test和hello这两个变量和程序运行的全路径名或程序的名字，argc即为3。

　　argv是一个char *的数组，其中存放指向参数变量的指针，此处argv[0]指向test.exe的全路径名或test.exe，argv[1]指向test，argv[2]指向hello。

3、实例

/*test_main.c*/
#include <stdio.h>

int main(int argc, char *argv[])
{
  printf("%d\n",argc);
  printf("\n");
  printf("%s\n",argv[0]);
  printf("%s\n",argv[1]);
  printf("%s\n",argv[2]);
  return 0;
}

编译运行

$ ./test_main.o wan tu sirui
$ ./test_main.o
wan
Tu

Reference

【1】int main(int argc,char* argv[]) 的含义和用法 - hxing - 博客园 (cnblogs.com)

【2】https://blog.csdn.net/qq_37212828/article/details/103153208

C 头文件重复定义问题

Tue, 12 Sep 2023 00:00:00 GMT

C 头文件重复定义问题

头文件是扩展名为 .h 的文件，包含了 C 函数声明和宏定义，被多个源文件中引用共享。有两种类型的头文件：程序员编写的头文件和编译器自带的头文件。在程序中要使用头文件，需要使用 C 预处理指令 #include 来引用它。前面我们已经看过 stdio.h 头文件，它是编译器自带的头文件。

引用头文件相当于复制头文件的内容，但是我们不会直接在源文件中复制头文件的内容，因为这么做很容易出错，特别在程序是由多个源文件组成的时候。

A simple practice in C 或 C++ 程序中，建议把所有的常量、宏、系统全局变量和函数原型写在头文件中，在需要的时候随时引用这些头文件。

使用预处理指令 #include 可以引用用户和系统头文件。它的形式有以下两种：

这种形式用于引用系统头文件。它在系统目录的标准列表中搜索名为 file 的文件。在编译源代码时，您可以通过 -I 选项把目录前置在该列表前。

这种形式用于引用用户头文件。它在包含当前文件的目录中搜索名为 file 的文件。在编译源代码时，您可以通过 -I 选项把目录前置在该列表前。

1、#ifndef和#pragma once两者的使用方式有何区别？

示例代码如下：

方式一：

#ifndef __SOMEFILE_H__
#define  __SOMEFILE_H__
 ... ... // 声明、定义语句
#endif

方式二：

#pragma once
 ... ... // 声明、定义语句

两者各有何特点？

（1）#ifndef

#ifndef的方式受C/C++语言标准支持。它不仅可以保证同一个文件不会被包含多次，也能保证内容完全相同的两个文件（或者代码片段）不会被不小心同时包含。

当然，缺点就是如果不同头文件中的宏名不小心“撞车”，可能就会导致你看到头文件明明存在，但编译器却硬说找不到声明的状况——这种情况有时非常让人郁闷。

由于编译器每次都需要打开头文件才能判定是否有重复定义，因此在编译大型项目时，ifndef会使得编译时间相对较长，因此一些编译器逐渐开始支持#pragma once的方式。

（2）#pragma once

#pragma once 一般由编译器提供保证：同一个文件不会被包含多次。注意这里所说的“同一个文件”是指物理上的一个文件，而不是指内容相同的两个文件。

你无法对一个头文件中的一段代码作pragma once声明，而只能针对文件。

其好处是，你不必再担心宏名冲突了，当然也就不会出现宏名冲突引发的奇怪问题。大型项目的编译速度也因此提高了一些。

对应的缺点就是如果某个头文件有多份拷贝，本方法不能保证他们不被重复包含。当然，相比宏名冲突引发的“找不到声明”的问题，这种重复包含很容易被发现并修正。

另外，这种方式不支持跨平台！

两者之间有什么联系？

#pragma once 方式产生于#ifndef之后，因此很多人可能甚至没有听说过。目前看来#ifndef更受到推崇。因为#ifndef受C/C++语言标准的支持，不受编译器的任何限制；

而#pragma once方式却不受一些较老版本的编译器支持，一些支持了的编译器又打算去掉它，所以它的兼容性可能不够好。

一般而言，当程序员听到这样的话，都会选择#ifndef方式，为了努力使得自己的代码“存活”时间更久，通常宁愿降低一些编译性能，这是程序员的个性，当然这是题外话啦。

还看到一种用法是把两者放在一起的：

 #pragma once
  #ifndef __SOMEFILE_H__
  #define __SOMEFILE_H__
  ... ... // 声明、定义语句
  #endif

总结：

看起来似乎是想兼有两者的优点。不过只要使用了#ifndef就会有宏名冲突的危险，也无法避免不支持#pragma once的编译器报错，所以混用两种方法似乎不能带来更多的好处，倒是会让一些不熟悉的人感到困惑。

选择哪种方式，应该在了解两种方式的情况下，视具体情况而定。只要有一个合理的约定来避开缺点，我认为哪种方式都是可以接受的。而这个已经不是标准或者编译器的责任了，应当由程序员自己或者小范围内的开发规范来搞定。

为了避免同一个文件被include多次

1 #ifndef方式 2 #pragma once方式

#ifndef的方式依赖于宏名字不能冲突，这不光可以保证同一个文件不会被包含多次，也能保证内容完全相同的两个文件不会被不小心同时包含。当然，缺点就是如果不同头文件的宏名不小心“撞车”，可能就会导致头文件明明存在，编译器却硬说找不到声明的状况

`#pragma once`则由编译器提供保证：同一个文件不会被包含多次。注意这里所说的“同一个文件”是指物理上的一个文件，而不是指内容相同的两个文件。带来的好处是，你不必再费劲想个宏名了，当然也就不会出现宏名碰撞引发的奇怪问题。对应的缺点就是如果某个头文件有多份拷贝，本方法不能保证他们不被重复包含。当然，相比宏名碰撞引发的“找不到声明”的问题，重复包含更容易被发现并修正。

方式一由语言支持所以移植性好，方式二可以避免名字冲突

2、为什么 stdio.h 不会被重定义

#include原则上只能包含头文件，不能包含cpp文件，否则可能出现重复定义的问题。
stdio.h等标准库头文件中已经含有防止重复包含的预编译指令，多次包含这些文件也不会出现任何问题。

Reference

【1】https://www.cnblogs.com/zhjblogs/p/14166866.html

Conda 和 pip 换源

Tue, 12 Sep 2023 00:00:00 GMT

Conda 和 pip 换源

conda

中科大源

conda config --add channels https://mirrors.ustc.edu.cn/anaconda/pkgs/main/
conda config --add channels https://mirrors.ustc.edu.cn/anaconda/pkgs/free/
conda config --add channels https://mirrors.ustc.edu.cn/anaconda/cloud/conda-forge/
conda config --add channels https://mirrors.ustc.edu.cn/anaconda/cloud/msys2/
conda config --add channels https://mirrors.ustc.edu.cn/anaconda/cloud/bioconda/
conda config --add channels https://mirrors.ustc.edu.cn/anaconda/cloud/menpo/
conda config --set show_channel_urls yes
conda config --remove-key channels        # 换回默认源

conda env remove --name your_env_name   # 删除环境

PIP

下载某一个文件的时候，临时使用中科大源，加上如下后缀就行

pip install xx -i https://pypi.mirrors.ustc.edu.cn/simple/

永久

pip install pip -U

在Jupyter笔记本中直接运行C语言代码并不直接支持，因为Jupyter是为Python、Julia、R和其他支持Jupyter内核的语言设计的。但是，你可以通过一些方法间接地在Jupyter笔记本中运行C语言代码：

#delete the env
conda remove -n lglc --all -y

# create the envirment for c
conda create -n lglc python==3.11
conda activate lglc

# change the conda source
conda config --add channels https://mirrors.ustc.edu.cn/anaconda/pkgs/main/
conda config --add channels https://mirrors.ustc.edu.cn/anaconda/pkgs/free/
conda config --add channels https://mirrors.ustc.edu.cn/anaconda/cloud/conda-forge/
conda config --add channels https://mirrors.ustc.edu.cn/anaconda/cloud/msys2/
conda config --add channels https://mirrors.ustc.edu.cn/anaconda/cloud/bioconda/
conda config --add channels https://mirrors.ustc.edu.cn/anaconda/cloud/menpo/
conda config --set show_channel_urls yes

# change the pip source

pip install pip -U

pip config set global.index-url https://pypi.mirrors.ustc.edu.cn/simple

# insall jupyter notebook

pip install numpy matplotlib jupyter

使用`!`前缀运行C代码

你可以使用Jupyter的shell命令功能来编译和运行C代码。这需要你已经在系统上安装了C编译器（如GCC）。

以下是如何在Jupyter笔记本中使用!前缀来编译和运行C代码的步骤：

首先，编写C代码并保存到文件中。

// hello.c
#include <stdio.h>

int main() {
    printf("Hello, World!\n");
    return 0;
}

使用!前缀运行命令来编译C代码。

!gcc hello.c -o hello

使用!前缀运行编译后的程序。

!./hello

使用`%%script`魔法命令

Jupyter还提供了%%script魔法命令，允许你在笔记本中运行脚本。这同样需要系统上安装了C编译器。

%%script bash
gcc hello.c -o hello && ./hello

使用`%%writefile`魔法命令

你可以使用%%writefile魔法命令将代码块写入文件，然后编译和运行它。

%%writefile hello.c
#include <stdio.h>

int main() {
    printf("Hello, World!\n");
    return 0;
}

接着编译并运行：

!gcc hello.c -o hello
!./hello

使用ctypes或cffi库

如果你想在Python代码中调用C函数，你可以使用ctypes或cffi库。这需要你创建一个C库，然后从Python中加载它。

这是一个使用ctypes的简单例子：

编写C代码并编译为共享库。

// mylib.c
#include <stdio.h>

void say_hello() {
    printf("Hello from C!\n");
}

编译为共享库：

!gcc -shared -o mylib.so -fPIC mylib.c

使用ctypes加载并调用C函数。

from ctypes import cdll

# 加载共享库
mylib = cdll.LoadLibrary('./mylib.so')

# 调用C函数
mylib.say_hello()

以上方法可以帮助你在Jupyter笔记本中运行C语言代码或调用C函数。记住，这些方法需要在你的系统上安装C编译器，并且它们不会在Jupyter笔记本内部执行C代码，而是通过外部命令或库调用。

中文字体

Tue, 12 Sep 2023 00:00:00 GMT

如果本来就没有中文字体，必须先安装并配置字体，保证有中文字体ttf的文件

配置：修改matplotlibrc配置字体

1. 首先定位matplotlib的字体库路径（我使用python进行定位）

import matplotlib
matplotlib.matplotlib_fname()

2. 将中文字体文件**.ttf，拷贝到该目录的fonts/ttf下

3. 删除 matplotlib 缓存

cd ~/.cache/matplotlib
rm * -r

4. 修改matplotlibrc文件：修改font.sans-serif 加入中文字体

font.sans-serif     : Microsoft YaHei, DejaVu Sans, Bitstream Vera Sans, Computer Modern Sans Serif, Lucida Grande, Verdana, Geneva, Lucid, Arial, Helvetica, Avant Garde, sans-serif, ***(刚加的字体名字)

5. 重启程序或在 jupyter中restart the kernel

应用一：用plt.rcParams设置

import matplotlib.pyplot as plt
plt.rcParams['font.sans-serif']=['Microsoft YaHei']
plt.xlabel('测试')
plt.show()

应用二：用FontProperties，并指定字体文件

from matplotlib.font_manager import FontProperties
import matplotlib.pyplot as plt
font = FontProperties(fname='/mnt/share/code/font/SimHei.ttf', size=20)
plt.title('测试', fontproperties=font)

参考

https://ask.hellobi.com/blog/safa/36673

Lapack 数学库动态静态库安装

Tue, 12 Sep 2023 00:00:00 GMT

Lapack 数学库动态静态库安装

LAPACK（Linear Algebra PACKage）库，是用Fortran语言编写的线性代数计算库，包含线性方程组求解（AX=b）、矩阵分解、矩阵求逆、求矩阵特征值、奇异值等。该库用BLAS库做底层运算，许多高层的数学库都用BLAS和LAPACK做底层。

 **BLAS（Basic Linear Algebra Subprograms）库**，是用Fortran语言实现的向量和矩阵运算库,是许多数值计算软件库的核心, 但也有一些其它的包装, 如cblas是C语言, 也有C++的包装, boost/ublas 是C++ template class的实现； 另外还有一些特别的实现, 如intel MKL, AMD core math library blas就是做向量、矩阵的基本运算，如加、减、乘等操作。

下载地址：https://netlib.org/lapack/

安装前提：有Cmake， GUN complier， python

1、编译

1.1 安装动态Lapack库

# dy-lib
$ tar -xvzf lapack-*.tar.gz
$ cd lapack-*
$ mkdir build && cd build
$ cmake .. -DCMAKE_BUILD_TYPE=RELEASE -DBUILD_SHARED_LIBS=ON -DCBLAS=ON   # 编译lapack 和 cblas
$ make -j 20   # 采用20个线程编译

1.2 安装静态Lapack库

 # static-lib
 $ cd lapack-*
 $ cp make.inc.example make.inc    # 设置头文件
 $ make -j20 blaslib
 $ make -j20 cblaslib
 $ make -j20 lapacklib
 $ make -j20 lapackelib

2、设置库和头文件

 # static-lib and dy-lib
 $ cd lapack-*
 # lib
 $ cp -r build/lib/ ./lib
 $ cp *.a ./lib
 # include
 $ cp CBLAS/incude/* ./include
 $ cp LAPACKE/incude/* ./include

3、配置环境变量

Bash Shell 实现程序并行

Mon, 12 Jun 2023 00:00:00 GMT

Bash Shell 实现程序并行

(2023.03.21)

1. Bash 简介_w3cschool

Bash shell 可以在文本中直接运行Liunx 命令。

Bash 是 Bourne Shell 程序“sh”的升级版本，这是一个开源 GNU 项目。它提供了比 Bourne Shell 更好的功能，适用于编程和交互使用。我们可以这么理解，Bash 是一个命令处理器，通常运行于文本窗口中，可以将用户输入的命令解释并执行相应的操作，这样式的文件被称作脚本。 Bash 是绝大多数 Linux 、MAC 及 OS 默认的 shell 程序，并且 Shell Script 都大致相同。当您学会一种 Shell 后，其它的 Shell 都能够很快上手，而且一种 Shell Script 通常可以在很多 Shell 上使用，因此您不必在学习哪种 Shell 的选择上耗费太多的时间。

2. Bash 示例

#!/bin/bash
# Part 1 注释
# 单行注释

<< BLOCK
1.
2.多行注释（1）
3.
BLOCK

:'
1.
2.多行注释（2）
3.'

3. 并行Bash

shell中的命令都是串行执行的，如果想要充分利用服务器的资源，需要一些小技巧

# do the Jobs
ii=$(((nshots+1)/$Worker))
jj=$(((nshots+1)%$Worker))
for((i=0;i<$ii;i++))
do
    for((j=0;j<$Worker;j++))
    do
    {
        job=$((i*$Worker+j))
        bash ./jobs/lgl_$job.sh
    } &     # 并行$Worker个程序
    done
    wait   # 等待完成 多个
done

4. 参考

1 Bash 教程总览_w3cschool

2 Shell-使用&和wait让你的脚本并行执行 - 腾讯云开发者社区-腾讯云 (tencent.com)

Ubuntu中一般的软件安装

Mon, 12 Jun 2023 00:00:00 GMT

Ubuntu中一般的软件安装

一、查看已安装软件

用 apt 命令显示已安装软件包：

apt list –installed

用 dpkg 命令显示已安装软件包:

dpkg-query -l

列出系统里 Snap 已安装软件包:

snap list

列出系统里 Flatpak 已安装软件包:

flatpak list

展示安装位置：

sudo  apt-get install aptitude

sudo aptitude show zip

二、Ubuntu中软件安装方法

1、APT方式 （1）普通安装：

apt-get install softname1 softname2 …;

（2）修复安装：

apt-get -f install softname1 softname2... ;(-f Atemp to correct broken dependencies)

（3）重新安装：

apt-get --reinstall install softname1 softname2...;

2、Dpkg方式 （1）普通安装：

dpkg -i package_name.deb

3、源码安装（.tar、tar.gz、tar.bz2、tar.Z） 首先解压缩源码压缩包然后通过tar命令来完成

    a．解xx.tar.gz：tar zxf xx.tar.gz
    b．解xx.tar.Z：tar zxf xx.tar.Z
    c．解xx.tgz：tar zxf xx.tgz
    d．解xx.bz2：bunzip2 xx.bz2
    e．解xx.tar：tar xf xx.tar

然后进入到解压出的目录中，建议先读一下README之类的说明文件，因为此时不同源代码包或者预编译包可能存在差异，然后建议使用ls -F --color或者ls -F命令（实际上我的只需要 l 命令即可）查看一下可执行文件，可执行文件会以*号的尾部标志。一般依次执行

./configure
 make
 sudo make install

即可完成安装。

三、Ubuntu中软件包的卸载方法

1、APT方式 （1）移除式卸载：

apt-get remove softname1 softname2 …;

（移除软件包，当包尾部有+时，意为安装）（2）清除式卸载：

apt-get --purge remove softname1 softname2...;(同时清除配置)

清除式卸载：

apt-get purge sofname1 softname2...;(同上，也清除配置文件)

2、Dpkg方式 （1）移除式卸载：

dpkg -r pkg1 pkg2 ...;

（2）清除式卸载：

dpkg -P pkg1 pkg2...;

四、其他

可以使用以下命令清理系统垃圾

sudo apt-get autoclean

清理旧版本的软件缓存

sudo apt-get clean

清理所有软件缓存

sudo apt-get autoremove

Reference

【1】 https://zhuanlan.zhihu.com/p/57472336

【2】https://blog.csdn.net/jasonzhoujx/article/details/80384029

【3】https://blog.csdn.net/qq_40150691/article/details/83026169

malloc与realloc的区别

Mon, 12 Jun 2023 00:00:00 GMT

malloc与realloc的区别

ANSI C说明了三个用于存储空间动态分配的函数 (1) malloc 分配指定字节数的存储区。此存储区中的初始值不确定 (2) calloc 为指定长度的对象，分配能容纳其指定个数的存储空间。该空间中的每一位(bit)都初始化为0 (3) realloc更改以前分配区的长度(增加或减少)。当增加长度时，可能需将以前分配区的内容移到另一个足够大的区域，而新增区域内的初始值则不确定。分配函数时再分配 realloc() ，使我们可以增、减以前分配区的长度(最常见的用法是增加该区)。如果先分配一个可容纳长度为512的数组的空间，并在运行时填充它，但又发现空间不够，则可调用realloc扩充该存储空间。如果在该存储区后有足够的空间可供扩充，则可在原存储区位置上向高地址方向扩充，并返回传送给它的同样的指针值。如果在原存储区后没有足够的空间，则realloc分配另一个足够大的存储区，将现存的512个元素数组的内容复制到新分配的存储区。因为这种存储区可能会移动位置，所以不应当使用任何指针指在该区中。注意，realloc的最后一个参数是存储区的newsize(新长度)，不是新、旧长度之差。作为一个特例，若ptr是一个空指针，则realloc的功能与malloc相同，用于分配一个指定长度newsize的存储区。

一.malloc

malloc的参数就是所需分配的字节数，malloc在c语言中不是关键字而是C函数库中提供的函数。调用malloc时就是在内存池中提取一块连续的空间，并返回这块内存的指针。代码示例：

#include <stdio.h>
#include <stdlib.h>
typedef struct node{
    int data;
    struct node *next;
}node;

node *create(int n)
{
    node *p = NULL, *head;
    head = (node*)malloc(sizeof (node ));
    p = head;	node *s;
    int i = 1;
    if( 0 != n )
    {
        while( i <= n )
        {
            s = (node *)malloc(sizeof (node));
            s->data = i++;    // 为循环链表初始化，第一个结点为1，第二个结点为2。
            p->next = s;
            p = s;
        }
        s->next = head->next;
    }
    free(head);
    return s->next ;
}

二.realloc

void realloc(void *ptr,size_t new_size); ptr是指向原来地址的指针，这个函数用于修改一个原先已经分配内存块的大小。

使用：

1.可以使一块内存扩大或缩小（原来的内存块可以扩大缩小）

（1.）如果是扩大一个内存块，则将原来的内存块保留在他的后边新增一块内存块（但是新增的内存块并未初始化）

（2.）如果是缩小一块内存块，则将该内存块的后半部分直接拿掉，剩余部分内存块及其内容保留。

2.原来的内存块无法扩大缩小

如果是着这种情况，realloc会重新开辟一个新的内存空间，并把原来的内存空间的内容拷贝到新的内存空间里。

注意：再调用完realloc后就不能使用指向就内存的指针，而是用返回的新的指针。

内存扩展如图所示。

值得一提的是：如果realloc中的第一个参数如果为空则和malloc一样。

#include<Windows.h>
#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>
int main()
{
    const int size = 2000;
    int *p = (int *)malloc(20 * sizeof(int));
    int *p1 = (int *)realloc(p, size*sizeof(int));
    printf("%x\n", p);
    printf("%x\n", p1);
    system("pause");
    return 0;
}

Reference

【1】https://blog.csdn.net/u010137839/article/details/78643503

podman 创建镜像

Mon, 12 Jun 2023 00:00:00 GMT

podman 创建镜像

一、dockerfile 语法

FROM：指定基础镜像。构建过程从此镜像开始。例如：

FROM ubuntu:18.04

这将使用Ubuntu 18.04版本的镜像作为构建过程的基础。

LABEL：添加元数据到镜像，这些元数据可以包含作者、版本等信息。例如：

LABEL maintainer="John Doe <john.doe@example.com>"

这将添加一个标签，其中包含维护者的信息。

RUN：在构建过程中执行命令。这些命令会在镜像的上下文中执行，并创建新的镜像层。例如：

RUN apt-get update && apt-get install -y \
    build-essential \
    wget \
    python3

这将使用apt-get update和apt-get install命令安装一些软件包。

CMD：指定容器启动时默认执行的命令。这些命令会被加入到容器启动时的命令中。例如：

CMD ["python3", "./app.py"]

这将使容器在启动时执行python3 ./app.py命令。

ENTRYPOINT：指定容器启动时执行的命令。这些命令会替换掉用户指定的命令。例如：

ENTRYPOINT ["python3", "./app.py"]

这将使容器在启动时执行python3 ./app.py命令，即使用户指定其他命令，这个命令也会被替换掉。

EXPOSE：声明容器监听的端口。这些端口会在启动容器时自动映射到宿主机的端口。例如：

EXPOSE 8080

这将使容器在启动时监听端口8080。

VOLUME：指定容器内的目录作为卷，用于持久化数据。例如：

VOLUME ["/data"]

这将使容器内的/data目录作为卷，用于持久化数据。

ENV：设置环境变量。这些环境变量可以在构建过程中使用，也可以在容器运行时使用。例如：

ENV NAME World

这将设置一个名为NAME的环境变量，其值为World。

USER：指定构建过程中使用的用户。例如：

USER root

这将使用root用户进行构建。

WORKDIR：指定构建过程中的工作目录。例如：

 WORKDIR /app

这将设置工作目录为`/app`。

COPY：将文件或目录从宿主机复制到镜像中。例如：

 COPY . /app

这将复制当前目录下的所有内容到镜像中的`/app`目录。

ADD：与COPY类似，但它可以自动解压压缩文件。例如：

 ADD ./path/to/source.tar.gz /app/path/to/destination/

这将自动解压`./path/to/source.tar.gz`文件到`/app/path/to/destination/`目录。

ONBUILD：指定当构建一个以当前镜像为基础的镜像时应该执行的命令。例如：

 ONBUILD ADD . /app

这将添加当前目录下的所有内容到以当前镜像为基础的镜像中的`/app`目录。

STOPSIGNAL：指定在容器停止时发送的信号。例如：

 STOPSIGNAL S

以下是一个简单的Dockerfile示例：

FROM ubuntu:18.04

RUN apt-get update && apt-get install -y \
 build-essential \
 wget \
 python3

WORKDIR /app

COPY . /app

RUN pip3 install -r requirements.txt

CMD ["python3", "./app.py"]

这个Dockerfile构建了一个基于Ubuntu 18.04的基础镜像，安装了构建必需的软件包，复制了应用程序代码，并安装了Python依赖。最后，它指定了容器启动时应该执行的命令。

二、podman的语法

Podman 是一个开源的容器引擎，用于构建、运行和连接容器。以下是一些基础的 Podman 命令：

`podman system migrate`   # repair the podman
`sudo systemctl restart podman`

构建镜像

podman build -t myimage .

这将使用当前目录中的 Dockerfile 构建一个名为 myimage 的镜像。

运行容器

podman run -it --rm myimage /bin/bash    --name xx

podman run --name lglsoft -it --rm --env=DISPLAY=180.201.179.79:0.0 susoft:latest  /bin/bash

podman run -it --device=/dev/dri:/dev/dri --volume=/tmp/.X11-unix:/tmp/.X11-unix:rw --volume=/etc/localtime:/etc/localtime:ro --env=DISPLAY=$DISPLAY dockerfile-su /bin/bash

这将使用名为 myimage 的镜像创建并运行一个交互式的容器。

列出容器

podman ps

这将列出当前正在运行的容器。

列出镜像

podman images

这将列出所有可用的镜像。

删除容器

podman rm mycontainer

这将删除名为 mycontainer 的容器。

删除镜像

podman rmi myimage
podman rmi <image_id>

这将删除名为 myimage 的镜像。

列出网络

podman network list

这将列出所有已创建的网络。

删除网络

podman network rm mynetwork

这将删除名为 mynetwork 的网络。

导出容器

podman export mycontainer > mycontainer.tar

这将导出名为 mycontainer 的容器为 tar 文件。

导入镜像

podman import myimage.tar myimage

这将导入名为 myimage.tar 的 tar 文件为镜像。

导出镜像

podman save myimage > myimage.tar

这将导出名为 myimage 的镜像为 tar 文件。

导入容器

podman import mycontainer.tar mycontainer

这将导入名为 mycontainer.tar 的 tar 文件为容器。

这些是一些基础的 Podman 命令，根据您的具体需求，可能还需要使用其他命令。Podman 的命令行选项和功能可能会随着版本更新而变化，因此建议查阅最新的 Podman 文档以获取最准确的信息

#########################################################################
# This Dockerfile builds a base image to run Seismic UNIX  on generic CPU
# architectures using GCC compilers and OpenMPI.
# WRITER: Guolong Li (1712343961@qq.com)
# TIME: 06.18.2024
#########################################################################

# Base image
FROM ubuntu:22.04 as base

# Verb=NO
ENV DEBIAN_FRONTEND noninteractive
LABEL maintainer="Guolong Li <1712343961@qq.com>"

# change the aliyun source to download software
RUN sed -i 's/archive.ubuntu.com/mirrors.aliyun.com/g' /etc/apt/sources.list
CMD ["/bin/bash"]
EXPOSE 8888

# cp Seismic Unix (unziped 44R28 and well configured)
RUN mkdir -p /Software/Seismic_Unix
ADD ./seismic_unix.tar.gz /Software/Seismic_Unix/
ENV CWPROOT=/Software/Seismic_Unix
ENV PATH=$PATH:/Software/Seismic_Unix/bin

# Install basic package
RUN apt-get update && \
 apt-get install -y build-essential mpich\
 git xorg gcc libx11-dev libxt-dev libxext-dev make libmotif-dev libtirpc-dev gfortran libglu1-mesa-dev freeglut3-dev \
 libxmu-dev libxmu-headers libxi-dev  libglu1-mesa-dev freeglut3-dev libxmu-dev libxmu-headers libxi-dev

# set the Basic var
ARG nproc="10"

# Install Seismic Unix (only support one thread)
RUN cd /Software/Seismic_Unix/src/ && ls &&    make install
RUN cd /Software/Seismic_Unix/src/ &&    make xtinstall
RUN cd /Software/Seismic_Unix/src/ &&    make finstall

# Install Miniconda
RUN mkdir -p /Software/Miniconda



# # Instal the OpenMPI
# ARG OMPI_BRANCH="v4.1.4"
# RUN mkdir -p /deps && mkdir -p /opt/openmpi && cd /deps && \
#     git clone --depth 1 --recursive --branch ${OMPI_BRANCH} https://github.com/open-mpi/ompi.git openmpi && \
#     cd openmpi && ./autogen.pl && \
#     mkdir build &&  cd build && \
#     ../configure --prefix=/opt/openmpi/ \
#                  --enable-mca-no-build=btl-uct --enable-mpi1-compatibility && \
#     make -j ${nproc} && \
#     make install && \
#     rm -rf /deps/openmpi

# # Set OpenMPI path
# ENV PATH=${PATH}:/opt/openmpi/bin
# ENV LD_LIBRARY_PATH=${LD_LIBRARY_PATH}:/opt/openmpi/lib

GCC的编译过程

Fri, 12 May 2023 00:00:00 GMT

GCC的编译过程

1、gcc的编译步骤

gcc编译：

4步骤：预处理、编译、汇编、连接。

-I：指定头文件所在目录位置。

-c：只做预处理、编译、汇编。得到二进制文件！！！

-g：编译时添加调试语句。主要支持 gdb 调试。

-Wall：显示所有警告信息。

-D：向程序中“动态”注册宏定义。 #define NAME VALUE

gcc 与 g++ 分别是 gnu 的 c & c++ 编译器 gcc/g++ 在执行编译工作的时候，总共需要4步：

1、预处理,生成 .i 的文件[预处理器cpp]

2、将预处理后的文件转换成汇编语言, 生成文件 .s [编译器egcs]

3、有汇编变为目标代码(机器代码)生成 .o 的文件[汇编器as]

4、连接目标代码, 生成可执行程序 [链接器ld]

2、gcc编译参数详解

-c

只激活预处理,编译,和汇编,也就是他只把程序做成obj文件

例子用法:

gcc -c hello.c

他将生成 .o 的 obj 文件

-S

只激活预处理和编译，就是指把文件编译成为汇编代码。

例子用法:

gcc -S hello.c

他将生成 .s 的汇编代码，你可以用文本编辑器察看。

-E

只激活预处理,这个不生成文件, 你需要把它重定向到一个输出文件里面。

例子用法:

gcc -E hello.c > pianoapan.txt
gcc -E hello.c | more

-o

制定目标名称, 默认的时候, gcc 编译出来的文件是 a.out, 很难听, 如果你和我有同感，改掉它, 哈哈。

例子用法:

gcc -o hello.exe hello.c
gcc -o hello.asm -S hello.c

-pipe

使用管道代替编译中临时文件, 在使用非 gnu 汇编工具的时候, 可能有些问题。

gcc -pipe -o hello.exe hello.c

-ansi

关闭 gnu c中与 ansi c 不兼容的特性, 激活 ansi c 的专有特性（包括禁止一些 asm inline typeof 关键字, 以及 UNIX,vax 等预处理宏）。

-include file

包含某个代码,简单来说,就是便以某个文件,需要另一个文件的时候,就可以用它设定,功能就相当于在代码中使用 #include<filename>。

例子用法:

gcc hello.c -include /root/pianopan.h

-Dmacro

相当于 C 语言中的 #define macro

-Dmacro=defn

相当于 C 语言中的 #define macro=defn

-Umacro

相当于 C 语言中的 #undef macro

-undef

取消对任何非标准宏的定义

-C

在预处理的时候, 不删除注释信息, 一般和-E使用, 有时候分析程序，用这个很方便的。

-M

生成文件关联的信息。包含目标文件所依赖的所有源代码你可以用 gcc -M hello.c 来测试一下，很简单。

-g

只是编译器，在编译的时候，产生调试信息。

-static

此选项将禁止使用动态库，所以，编译出来的东西，一般都很大，也不需要什么动态连接库，就可以运行。

-share

此选项将尽量使用动态库，所以生成文件比较小，但是需要系统由动态库。

GCC 是 GNU 的 C 和 C++ 编译器。实际上，GCC 能够编译三种语言：C、C++ 和 Object C（C 语言的一种面向对象扩展）。利用 gcc 命令可同时编译并连接 C 和 C++ 源程序。

gcc 命令的常用选项

选项	解释
-ansi	只支持 ANSI 标准的 C 语法。这一选项将禁止 GNU C 的某些特色，例如 asm 或 typeof 关键词。
-c	只编译并生成目标文件。
-DMACRO	以字符串"1"定义 MACRO 宏。
-DMACRO=DEFN	以字符串"DEFN"定义 MACRO 宏。
-E	只运行 C 预编译器。
-g	生成调试信息。GNU 调试器可利用该信息。
-IDIRECTORY	指定额外的头文件搜索路径DIRECTORY。
-LDIRECTORY	指定额外的函数库搜索路径DIRECTORY。
-lLIBRARY	连接时搜索指定的函数库LIBRARY。
-m486	针对 486 进行代码优化。
-o FILE	生成指定的输出文件。用在生成可执行文件时。
-O0	不进行优化处理。
-O 或 -O1	优化生成代码。
-O2	进一步优化。
-O3	比 -O2 更进一步优化，包括 inline 函数。
-shared	生成共享目标文件。通常用在建立共享库时。
-static	禁止使用共享连接。
-UMACRO	取消对 MACRO 宏的定义。
-w	不生成任何警告信息。
-Wall	生成所有警告信息。

Reference

【1】https://www.runoob.com/w3cnote/gcc-parameter-detail.html

OpenMP学习目录

Fri, 12 May 2023 00:00:00 GMT

OpenMP学习目录

OpenMP

§OpenMP

OpenMP (Open Multi-Processing)是一套支持跨平台共享内存方式的多线程并发的编程API，使用C,C++和Fortran语言，可以在大多数的处理器体系和操作系统中运行。OpenMP包括一套编译器指令、库和一些能够影响运行行为的环境变量。OpenMP采用#pragma omp来控制线程，即使用c/c++标准留给编译器厂商的实现定义行为控制语法来实现，因此OpenMP标准针对的是编译器厂商。要确定某个平台是否支持OpenMP，只需要看是否有支持OpenMP的编译器，如windows的visual studio编译器只支持OpenMP 2.0，而最新版的OpenMP标准为OpenMP5.0，因此windows平台对OpenMP的支持不太友好。

§例1、向量加法

// 文件：vector_add_omp.cpp
#include <iostream>
#include <vector>

int main() {
    const int n = 10;
    std::vector<int> v1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    std::vector<int> v2 = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1};
    std::vector<int> v3(n);

    #pragma omp parallel for
    for (int i = 0; i < n; ++i)
        v3[i] = v1[i] + v2[i];

    for (int i = 0; i < n; ++i)
        std::cout << v3[i] << " ";
    std::cout << std::endl;

    return 0;
}

编译：g++ -fopenmp vector_add_omp.cpp -o vector_add_omp

执行：

$ ./vector_add_omp
11 11 11 11 11 11 11 11 11 11

OpenMP采用fork/join并行模式，程序开始时只有一个主线程，程序中的串行部分由主线程执行，并行部分派生其它线程共同执行，所有线程执行完毕后才会退出并行区域，因此在输出v3时可以确保已经计算完成。

parallel for中循环小括号内的语句必须按照一定的规范书写才能并行：

(1) 第一条语句是循环变量初始化的语句，必须写成"变量=初值"的形式。如i=0。

(2) 第二条语句是循环限制语句，必须为这4种形式之一：i < n、 i <= n、 i > n、 i>= n。需要注意循环中不能有影响循环次数的语句，如break语句或者改变循环变量的语句。

(3) 第三条语句改变循环变量，必须写成这9种形式之一：i++、++i、i--、--i、i += inc、i -= inc、i = i + inc、i = i - inc、i = inc + i。

此外，还需要注意的是，程序中的变量有共享和线程私有之分，在parallel for中，凡是for循环中声明的变量都是线程私有的，每个线程都有一份，而for循环外声明的为所有线程共享的。

§例2、向量内积

// 文件：vector_dot_omp.cpp
#include <iostream>
#include <vector>

int main() {
    const int n = 10;
    std::vector<int> v1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    std::vector<int> v2 = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1};

    int sum = 0;

    #pragma omp parallel for reduction(+:sum)
    for (int i = 0; i < n; ++i)
        sum += v1[i] * v2[i];

    std::cout << sum << std::endl;

    return 0;
}

编译：g++ -fopenmp vector_dot_omp.cpp -o vector_dot_omp

执行：

$ ./vector_dot_omp
220

reduction对一个或多个变量指定一个操作符，每个线程将创建变量的一个私有拷贝，在区域结束处，用指定的操作符将私有拷贝的值进行归约，然后用归约的结果更新原来的变量。如vector_dot_omp.cpp中，每个线程中都有自己的局部变量sum，然后计算一部分和，最后将所有的部分和相加，更新共享的变量sum。

reduction支持8种操作符，创建私有变量时使用的初始值依赖于操作符，如下表所示：

| 操作符 | + | - | * | & | | | ^ | && | || | | --- | --- | --- | --- | --- | --- | --- | --- | --- | | 初始值 | 0 | 0 | 1 | ~0 | 0 | 0 | 1 | 0 |

显然，分段后的计算结果要与串行结果相同，使用的运算必须满足交换率和结合率，减法是不满足这两条性质的，而上表却出现了减法，这是因为此处的减法和加法的效果基本相同，使用场合为：

#pragma omp parallel for reduction(-:sum)
for (int i = 0; i < n; ++i)
    sum -= v1[i] * v2[i];

它和下面的代码计算结果实际上是相同的：

#pragma omp parallel for reduction(+:sum)
for (int i = 0; i < n; ++i)
    sum -= v1[i] * v2[i];

§OpenMP指令

在c/c++中，OpenMP的基本使用方法为：

#pragma omp directives [clause[[,] clause] ... ]

OpenMP的指令有：parallel, for, sections, critical等。

§parallel指令

parallel指令用于定义一个并行执行的代码块。如：

#include <cstdio>
#include <omp.h>

int main() {
    #pragma omp parallel
    {
        int i = omp_get_thread_num();

        // 连续cout不是线程安全的，只能使用printf
        // std::cout << "Hello from thread " << i << "\n";
        printf("Hello from thread %d\n", i);
    }
}

执行结果：

Hello from thread 6
Hello from thread 3
Hello from thread 4
Hello from thread 1
Hello from thread 0
Hello from thread 5
Hello from thread 7
Hello from thread 2

§for指令

for指令的语法为：

#pragma omp [parallel] for [clauses]
for_statement

如果不加parallel，后面所跟的for循环只在某一个线程内运行，而如果出现在parallel声明的块内则相当于parallel for。如：

#include <cstdio>
#include <vector>

int main() {
    #pragma omp for
    for (int i = 0; i < 4; ++i)
        printf("%d ", i);
    printf("\n");

    #pragma omp parallel
    {
        #pragma omp for
        for (int i = 0; i < 4; ++i)
            printf("%d ", i);
    }
    printf("\n");

    return 0;
}

执行结果为：

§sections指令

sections指令用于指定分别在多个线程内执行的代码块，语法为：

#pragma omp [parallel] sections [clauses]
{
    #pragma omp section
    {
        code_block
    }
}

例如：

#include <cstdio>
#include <omp.h>

int main() {
    #pragma omp parallel sections
    {
        #pragma omp section
        printf("section1, thread id is %d\n", omp_get_thread_num());

        #pragma omp section
        printf("section2, thread id is %d\n", omp_get_thread_num());

        #pragma omp section
        printf("section3, thread id is %d\n", omp_get_thread_num());

        #pragma omp section
        printf("section4, thread id is %d\n", omp_get_thread_num());
    }

    return 0;
}

执行结果为：

section 3, thread id is 5
section 1, thread id is 6
section 2, thread id is 1
section 4, thread id is 7

可见的确是在不同的线程中执行的。

§critical指令

critical指令用于指定一个代码块为临界区。语法为：

#pragma omp critical [(name)]
{
    code_block
}

例如：

#include <iostream>
#include <vector>

int main() {
    std::vector<int> nums = {2, 3, 12, 43, 4, 21, 54, 35, 34, 5, 2435, 3425, 34, 5};

    int max = nums[0];

    #pragma omp parallel for
    for (int i = 1; i < nums.size(); ++i) {
        if (nums[i] > max) {
            #pragma omp critical
            {
                if (nums[i] > max)
                    max = nums[i];
            }
        }
    }

    std::cout << max << std::endl;

    return 0;
}

执行结果为：3425

这个程序设计得不好，求最大值或者最小值显然是满足交换率和结合率的，应当使用归约来求。

§OpenMP子句

在c/c++中，OpenMP的基本使用方法为：

#pragma omp directives [clause[[,] clause] ... ]

OpenMP子句有：if, num_threads, private, reduction等。

§if子句

if子句用于指定接下来的代码块是否并行，可以出现在parallel、for和sections后面。如：

std::vector<int> add(const std::vector<int> &v1,
                     const std::vector<int> &v2,
                     bool parallel = true) {
    std::vector<int> v3(v1.size());

    #pragma omp parallel for if (parallel)
    for (int i = 0; i < v1.size(); ++i)
        v3[i] = v1[i] + v2[i];

    return v3;
}

当传入的参数parallel为false时两个向量执行串行加法。

§num_threads子句

num_threads子句用于指定并行的线程数量，可以出现在parallel、for和sections后面。如sections指令一节的示例程序输出结果的线程编号不是预期的0, 1, 2, 3的排列，这是因为默认使用8个线程进行并行，将其改成4个线程：

#pragma omp parallel sections num_threads(4)
{
    #pragma omp section
    printf("section1, thread id is %d\n", omp_get_thread_num());

    #pragma omp section
    printf("section2, thread id is %d\n", omp_get_thread_num());

    #pragma omp section
    printf("section3, thread id is %d\n", omp_get_thread_num());

    #pragma omp section
    printf("section4, thread id is %d\n", omp_get_thread_num());
}

执行结果为：

section4, thread id is 3
section3, thread id is 2
section2, thread id is 0
section1, thread id is 1

§private子句

private子句用于将一个或多个变量声明成线程私有的变量，线程间无法相互访问这个变量，也无法访问并行区域外的同名共享变量。例如：

int n = 1;
#pragma omp parallel for private(n)
for (n = 8; n < 12; ++n)
    printf("%d\n", n);
printf("%d\n", n);

执行结果为：8 11 10 9 1

因此以private声明的变量和并行区域外的同名变量没有任何联系。

§reduction子句

reduction的功能如例2所述，可以出现在parallel、for和sections之后。

§OpenMP函数

在c/c++中，使用OpenMP的函数需要包含头文件<omp.h>。以下为一个简单的函数列表：

// 设置并行区域线程数
void omp_set_num_threads(int _Num_threads);

// 返回当前线程数目，在串行代码中调用将返回1
int omp_get_num_threads(void);

// 返回程序的最大可用线程数量
int omp_get_max_threads(void);

// 返回当前线程id，从0开始编号
int omp_get_thread_num(void);

// 返回程序可用的处理器数
int omp_get_num_procs(void);

// 启用或禁用可用线程数的动态调整(缺省情况下启用动态调整)。
void omp_set_dynamic(int _Dynamic_threads);

// 确定在程序中此处是否启用了动态线程调整。
int omp_get_dynamic(void);

// 确定线程是否在并行区域的动态范围内执行
int omp_in_parallel(void);

// 启用或禁用嵌套并行操作
void omp_set_nested(int _Nested);

// 确定在程序中此处是否启用了嵌套并行操作
int omp_get_nested(void);


// 初始化一个（嵌套）互斥锁
void omp_init_lock(omp_lock_t * _Lock);
void omp_init_nest_lock(omp_nest_lock_t * _Lock);

// 销毁一个（嵌套）互斥锁并释放内存
void omp_destroy_lock(omp_lock_t * _Lock);
void omp_destroy_nest_lock(omp_nest_lock_t * _Lock);

// 获得一个（嵌套）互斥锁
void omp_set_lock(omp_lock_t * _Lock);
void omp_set_nest_lock(omp_nest_lock_t * _Lock);

// 释放一个（嵌套）互斥锁
void omp_unset_lock(omp_lock_t * _Lock);
void omp_unset_nest_lock(omp_nest_lock_t * _Lock);

// 试图获得一个（嵌套）互斥锁，并在成功时放回真，失败时返回假
int omp_test_lock(omp_lock_t * _Lock);
int omp_test_nest_lock(omp_nest_lock_t * _Lock);

// 从过去的某一时刻经历的时间，一般用于成对出现，进行时间比较
double omp_get_wtime(void);

// 得到clock ticks的秒数
double omp_get_wtick(void);

例：

#include <iostream>
#include <vector>
#include <random>
#include <omp.h>

int main() {
    const int N = 100000000;   // 一亿
    std::vector<double> A(N);

    std::uniform_real_distribution<double> dist(0, 10);
    std::random_device rd;

    double start = 0;
    double end = 0;
    double elapsed = 0;

    // 串行
    start = omp_get_wtime();
    std::default_random_engine re{rd()};
    for (int i = 0; i < N; i++)
        A[i] = dist(re);
    end = omp_get_wtime();
    elapsed = end - start;
    std::cout << "generate " << N << " numbers in series elapsed: "
              << elapsed << " s" << std::endl;

    // 并行
    start = omp_get_wtime();
    #pragma omp parallel
    {
        int num_threads = omp_get_num_threads();
        std::default_random_engine re{rd()};
        for (int i = omp_get_thread_num(); i < N; i += num_threads)
            A[i] = dist(re);
    }
    end = omp_get_wtime();
    elapsed = end - start;
    std::cout << "generate " << N << " numbers in parallel elapsed: "
              << elapsed << " s" << std::endl;

    return 0;
}

执行结果为：

generate 100000000 numbers in series elapsed: 6.45648 s
generate 100000000 numbers in parallel elapsed: 1.18125 s

§参考

[1] OpenMP标准：https://www.openmp.org/wp-content/uploads/OpenMP-API-Specification-5.0.pdf.

OpenMP

Jupyter工作站配置

Wed, 12 Apr 2023 00:00:00 GMT

Jupyter工作站配置

1、安装 jupyter notebook

conda install jupyter

2、配置Jupyter-config

2.1、生成jupyter配置文件

jupyter-notebook --generate-config

该命令执行后会生成./jupyter/jupyter_notebook_config.py的文件

2.2 修改Jupyter_notebook_config.py该配置文件

c.NotebookApp.ip = ''   # 设置访问IP（工作站静态IP）

c.NotebookApp.open_browser = False  # 默认不自动打开浏览器

c.NotebookApp.password = ''            # 输入刚刚生成的密钥

c.NotebookApp.port = 8888            # 设置端口， 其他端口应该也是可以的

c.NotebookApp.notebook_dir = ''   # 设置Jupyternotebook 打开的根目录

上述代码c.NotebookApp.password = ''的设置，需要你在服务器上依次执行如下命令：

python
from notebook.auth import passwd
passwd()

大概如图：

然后运行完passwd()之后会得到一串密码，放入c.NotebookApp.password = ''里面。

上述代码c.NotebookApp.notebook_dir = ''的设置，这里你需要在引号中加入路径即可。

或者jupyter notebook password

Reference：

【1】https://blog.csdn.net/W_nihao_123456/article/details/108421145

Docker 安装实现docker默认安装目录修改

Sun, 12 Mar 2023 00:00:00 GMT

Docker 安装实现docker默认安装目录修改

一、安装

查看 Windows 上安装 Docker Desktop官方安装指南：

https://docs.docker.com/desktop/install/windows-install/

1、提前在D盘新建Program\Docker，使用这行代码安装：

"Docker Desktop Installer.exe" install --installation-dir="PATH"

2、" " 里面为你的Docker Desktop Installer.exe文件存放目录，PATH替换你想要安装路径：

"D:\Download\Docker Desktop Installer.exe"  install --installation-dir="D:\Program\Docker"

3、最后显示Installation succeeded代表安装成功。

二、更改镜像默认保存路径

1、运行docker，进入设置页，点击Resources选项，发现镜像默认安装在%UserProfile%\AppData\Local\Docker\wsl目录下

2、点击Browse按钮，选择自定义的其他盘路径，例如：D:\Program\

如下图所示：

3、最后点击Apply & restart按钮重启Docker即可生效。

4、docker会自动在选定的目录下增加子目录DockerDesktopWSL。

当然除以上方法还有很多中可以修改docker默认安装路径及 docker镜像的。

例如：软链接方法；WSL命令备份、导入方法等等，大家可以自行搜索一下。

Reference

【1】https://www.cnblogs.com/luzhuangzhi/p/17869210.html

【2】💻 Docker 快速安装软件 - Docker 快速入门 - 易文档 (easydoc.net)

CUDA性能分析

Thu, 12 Jan 2023 00:00:00 GMT

CUDA性能分析

命令

nsys profile --stats=true

示例

iguolong@node01:~/SOFTWARE/LGLSOFTWARE/src/2D/fdtd$ nsys profile --stats=true ./gpu2dafdshots  vp=vel.rsf  den=den.rsf geo=geo.txt nbell=2  npml=10 fm=7 freesrf=y log=log.txt int NGPU=2 GPU_lists=0,2
WARNING: CPU IP/backtrace sampling not supported, disabling.
Try the 'nsys status --environment' command to learn more.

WARNING: CPU context switch tracing not supported, disabling.
Try the 'nsys status --environment' command to learn more.

Generating '/tmp/nsys-report-dd6b.qdstrm'
[1/8] [========================100%] report1.nsys-rep
[2/8] [========================100%] report1.sqlite
[3/8] Executing 'nvtxsum' stats report
SKIPPED: /data1/Uers_Login/liguolong/SOFTWARE/LGLSOFTWARE/src/2D/fdtd/report1.sqlite does not contain NV Tools Extension (NVTX) data.

[4/8] Executing 'osrtsum' stats report

Time (%)  Total Time (ns)  Num Calls    Avg (ns)       Med (ns)      Min (ns)     Max (ns)     StdDev (ns)            Name
 44.3    1,742,654,423         35   49,790,126.4   29,092,600.0        1,565  239,680,504   56,054,598.9  poll
 25.7    1,009,566,364          4  252,391,591.0  160,490,033.0   30,028,539  658,557,759  277,831,157.7  sem_wait
 25.4    1,000,183,939          2  500,091,969.5  500,091,969.5  500,084,193  500,099,746       10,997.6  pthread_cond_timedwait
  3.0      116,840,484      1,197       97,611.1       11,747.0        1,033   15,257,078      792,696.0  ioctl
  1.0       38,133,974         12    3,177,831.2        5,009.0        1,401   38,041,261   10,979,139.6  fgets
  0.4       14,183,720          1   14,183,720.0   14,183,720.0   14,183,720   14,183,720            0.0  dup
  0.1        4,953,654         16      309,603.4        1,861.0        1,141    4,924,647    1,230,678.5  read
  0.1        3,183,639         55       57,884.3       10,100.0        5,280      963,461      177,045.2  mmap64
  0.0          700,807         18       38,933.7       22,897.5       11,785      119,303       36,505.9  sem_timedwait
  0.0          538,426         35       15,383.6        7,186.0        1,550      189,496       32,771.7  mmap
  0.0          489,544          1      489,544.0      489,544.0      489,544      489,544            0.0  popen
  0.0          464,601         96        4,839.6        4,271.5        1,888       11,338        1,812.6  open64
  0.0          424,590          7       60,655.7       63,006.0       39,092       68,901        9,969.2  pthread_create
  0.0          416,040         92        4,522.2        2,548.5        1,117       58,340        7,089.2  fopen
  0.0          262,854         51        5,154.0        3,291.0        1,146       33,709        5,664.8  fread
  0.0          218,350          2      109,175.0      109,175.0        6,742      211,608      144,862.1  send
  0.0          198,363          1      198,363.0      198,363.0      198,363      198,363            0.0  pthread_mutex_lock
  0.0          165,822         10       16,582.2        8,688.0        5,319       76,080       21,510.9  fflush
  0.0          127,939         50        2,558.8        1,705.0        1,003       18,410        2,843.2  fclose
  0.0           86,016          8       10,752.0        3,164.0        1,003       59,719       20,041.5  recvmsg
  0.0           74,485          1       74,485.0       74,485.0       74,485       74,485            0.0  pthread_cond_wait
  0.0           44,252          9        4,916.9        4,474.0        1,885        7,006        1,720.7  munmap
  0.0           28,084          5        5,616.8        4,728.0        2,872       10,850        3,041.8  pthread_cond_broadcast
  0.0           27,774         16        1,735.9        1,601.0        1,097        2,633          533.3  write
  0.0           24,613          6        4,102.2        4,925.0        1,263        6,413        2,100.4  open
  0.0           21,356          5        4,271.2        3,835.0        3,288        6,142        1,179.1  freopen
  0.0           18,862          3        6,287.3        7,239.0        3,818        7,805        2,157.1  socket
  0.0           15,586          3        5,195.3        5,928.0        3,097        6,561        1,844.6  pipe2
  0.0           14,706          4        3,676.5        2,687.0        1,967        7,365        2,514.5  fwrite
  0.0           14,072          1       14,072.0       14,072.0       14,072       14,072            0.0  connect
  0.0           10,824          2        5,412.0        5,412.0        4,800        6,024          865.5  fopen64
  0.0           10,018          6        1,669.7        1,693.0        1,031        2,176          410.2  fcntl
  0.0            6,324          1        6,324.0        6,324.0        6,324        6,324            0.0  putc
  0.0            4,877          2        2,438.5        2,438.5        2,001        2,876          618.7  bind
  0.0            1,009          1        1,009.0        1,009.0        1,009        1,009            0.0  fputs

[5/8] Executing 'cudaapisum' stats report

 Time (%)  Total Time (ns)  Num Calls  Avg (ns)   Med (ns)   Min (ns)  Max (ns)   StdDev (ns)           Name
  92.6      497,094,802    120,054    4,140.6    4,068.0     3,283    728,164     3,541.6  cudaLaunchKernel
  6.2       33,100,190      2,235   14,809.9    3,638.0     2,852  9,293,949    304,133.2  cudaMemcpyAsync
  0.5        2,602,744         90   28,919.4    5,115.5       245    424,303     82,776.6  cudaFree
  0.3        1,829,814         78   23,459.2    6,066.0     3,972    251,066     49,384.5  cudaMalloc
  0.2        1,332,591          2  666,295.5  666,295.5    19,398  1,313,193    914,851.2  cudaHostAlloc
  0.1          427,207         78    5,477.0    4,941.5     2,507     19,464      2,742.1  cudaMemsetAsync
  0.1          401,078          2  200,539.0  200,539.0    18,862    382,216    256,930.1  cudaFreeHost
  0.0           93,598          2   46,799.0   46,799.0    22,372     71,226     34,545.0  cudaMemset
  0.0           43,855          3   14,618.3    8,381.0     6,087     29,387     12,841.4  cudaStreamCreate
  0.0           42,362          6    7,060.3    6,619.0     4,485     11,430      2,742.8  cudaEventRecord
  0.0           18,465          6    3,077.5    1,425.5       464      8,707      3,401.4  cudaEventCreate
  0.0           17,320          3    5,773.3    6,277.0     4,083      6,960      1,503.2  cudaStreamDestroy
  0.0           10,439          3    3,479.7    3,867.0     1,953      4,619      1,374.6  cudaStreamSynchronize
  0.0            8,055          3    2,685.0    2,640.0     2,544      2,871        168.1  cudaEventSynchronize
  0.0            5,019          6      836.5      696.5       365      1,565        526.0  cudaEventDestroy
  0.0            1,400          1    1,400.0    1,400.0     1,400      1,400          0.0  cuModuleGetLoadingMode

[6/8] Executing 'gpukernsum' stats report

 Time (%)  Total Time (ns)  Instances  Avg (ns)  Med (ns)  Min (ns)  Max (ns)  StdDev (ns)     GridXYZ         BlockXYZ               Name
 36.4      163,783,064     30,003   5,458.9   5,728.0     4,864     6,400        378.1    13   25    1    16   16    1  _kernel_Acoustic2d_cpml_t
 32.4      146,070,544     30,003   4,868.5   5,088.0     4,383     5,728        335.5    13   25    1    16   16    1  _kernel_Acoustic2d_cpml_v
 15.9       71,828,147     30,003   2,394.0   2,495.0     2,175     3,135        146.8    24    1    1    16    1    1  _kernel_seis2d_record
 15.2       68,640,277     30,003   2,287.8   2,336.0     2,079     2,944        133.5     5    5    1     1    1    1  _kernel_add2d_bellwlt
  0.0           14,336          6   2,389.3   2,448.0     2,208     2,528        144.1    14   25    1     1   16    1  _kernel_mod2d_pad_z1
  0.0           13,248          6   2,208.0   2,272.0     2,016     2,304        126.4    13   14    1    16    1    1  _kernel_mod2d_pad_x0
  0.0           13,184          6   2,197.3   2,256.0     2,016     2,304        130.6    13   14    1    16    1    1  _kernel_mod2d_pad_x1
  0.0           13,152          6   2,192.0   2,256.0     1,984     2,272        119.3     4   25    1     1   16    1  _kernel_mod2d_pad_z0
  0.0           12,321          3   4,107.0   4,129.0     3,904     4,288        192.9    13   25    1    16   16    1  _kernel_vel_trans2d
  0.0            9,120          3   3,040.0   2,976.0     2,656     3,488        419.7   626    1    1    16    1    1  _kernel_pro_2d_sou_P
  0.0            7,360          3   2,453.3   2,528.0     2,272     2,560        157.9    10   25    1     1   16    1  _kernel_cpml2d_abcz1
  0.0            6,752          3   2,250.7   2,336.0     2,080     2,336        147.8    13   10    1    16    1    1  _kernel_cpml2d_abcx0
  0.0            6,720          3   2,240.0   2,304.0     2,080     2,336        139.5    13   10    1    16    1    1  _kernel_cpml2d_abcx1
  0.0            5,792          3   1,930.7   1,984.0     1,792     2,016        121.2     5    5    1     1    1    1  _kernel_bell2d_coff

[7/8] Executing 'gpumemtimesum' stats report

Time (%)  Total Time (ns)  Count   Avg (ns)     Med (ns)    Min (ns)   Max (ns)   StdDev (ns)      Operation
 86.8       22,741,397      3  7,580,465.7  7,258,355.0  7,136,657  8,346,385    666,090.8  [CUDA memcpy DtoH]
 12.3        3,222,238  2,232      1,443.7      1,440.0        864      4,800        174.3  [CUDA memcpy HtoD]
  0.9          236,702     80      2,958.8      2,240.0        831     21,536      4,038.6  [CUDA memset]

[8/8] Executing 'gpumemsizesum' stats report

Total (MB)  Count  Avg (MB)  Med (MB)  Min (MB)  Max (MB)  StdDev (MB)      Operation
 51.246     80     0.641     0.008     0.000    14.761        2.808  [CUDA memset]
 44.284      3    14.761    14.761    14.761    14.761        0.000  [CUDA memcpy DtoH]
  1.795  2,232     0.001     0.001     0.000     0.040        0.001  [CUDA memcpy HtoD]

Generated: /data1/Uers_Login/liguolong/SOFTWARE/LGLSOFTWARE/src/2D/fdtd/report1.nsys-rep /data1/Uers_Login/liguolong/SOFTWARE/LGLSOFTWARE/src/2D/fdtd/report1.sqlite

C 库函数 - perror()

Thu, 12 Jan 2023 00:00:00 GMT

C 库函数 - perror()

描述

C 库函数 void perror(const char *str) 把一个描述性错误消息输出到标准错误 stderr。首先输出字符串 str，后跟一个冒号，然后是一个空格。

声明

下面是 perror() 函数的声明。

void perror(const char *str)

参数

str -- 这是 C 字符串，包含了一个自定义消息，将显示在原本的错误消息之前。

返回值

该函数不返回任何值。

实例

下面的实例演示了 perror() 函数的用法。

#include <stdio.h>

int main ()
{
   FILE *fp;

   /* 首先重命名文件 */
   rename("file.txt", "newfile.txt");

   /* 现在让我们尝试打开相同的文件 */
   fp = fopen("file.txt", "r");
   if( fp == NULL ) {
      perror("Error: ");
      return(-1);
   }
   fclose(fp);

   return(0);
}

让我们编译并运行上面的程序，这将产生以下结果，因为我们尝试打开一个不存在的文件：

Error: : No such file or directory

Reference

【1】C 库函数 – perror() | 菜鸟教程 (runoob.com)

fftw 编译安装教程

Thu, 12 Jan 2023 00:00:00 GMT

fftw 编译安装教程

1、DFT && FFT-> FFTW

DFT（Discrete Fourier Transform），即离散傅里叶变换，是傅里叶变换在时域和频域上都呈离散的形式,将信号的时域采样变换为其DTFT的频域采样。

FFT（Fast Fourier Transformation），即为快速傅氏变换，是离散傅氏变换（DFT）的快速算法，它是根据离散傅氏变换的奇、偶、虚、实等特性，对离散傅立叶变换的算法进行改进获得的。

FFTW ( the Faster Fourier Transform in the West)是一个快速计算离散傅里叶变换的标准C语言程序集，其由MIT的M.Frigo和S. Johnson开发。可计算一维或多维实和复数据以及任意规模的DFT。

官网地址：传送门 (opens new window)，下载地址：传送门 (opens new window)。

2 、FFTW库所需的编译环境

GNU Compiler + MPI Compiler （如果编译mpi版的fftw）

2.1 默认编译

安装fftw仅需要遵循常见的三步骤即可（configure+make+make install），在这里先介绍一下默认安装，再然着重介绍一些configure的配置选项。

以fftw-3.3.6-pl2.tar.gz为例，先从官网下载该压缩包。解压缩，并进入源码目录进行编译即可。

$ tar zxvf fftw-3.3.6-pl2.tar.gz
$ cd fftw-3.3.6-pl2
$ ./configure
$ make
$ make install

这样就可以把fftw库按照默认配置，安装到默认的路径下。使用的是GNU的编译器，安装到的是/usr/local下面。

2.2 优化编译参数介绍

但是，我们通常会依据./configure -help得到的信息来添加一些参数来达到优化编译的目录。接下来我们使用命令查看一些常用配置参数：

设定安装目录

Installation directories:
--prefix=PREFIX    install architecture-independent files in PREFIX[/usr/local]

是否编译动态库

Optional Features:
--enable-shared[=PKGS]    build shared libraries [default=no]

是否编译静态库

--enable-static[=PKGS]    build static libraries [default=yes]

是否编译单精度版本

--enable-single         compile fftw in single precision
--enable-float          synonym for --enable-single

开启针对特定机器架构的优化，这个取决于机器CPU（下面有介绍）。

--enable-sse            enable SSE optimizations
--enable-sse2           enable SSE/SSE2 optimizations
--enable-avx            enable AVX optimizations
--enable-avx2           enable AVX2 optimizations
--enable-neon           enable ARM NEON optimizations

开启积和熔加运算(Fused Multiply-Add/FMA)的优化

--enable-fma            enable optimizations for machineswith fused multiply-add

是否编译mpi版的fftw库

--enable-mpi            compile FFTW MPI library

是否使用OpenMP指令进行并行

--enable-openmp         use OpenMP directives for parallelism

是否编译FFTW SMP线程库

--enable-threads        compile FFTW SMP threads library

这部分是指定编译器及编译参数，默认是用GNU的编译器：

Some influential environment variables:
  CC          C compiler command
  CFLAGS      C compiler flags
  CPP         C preprocessor
  MPICC       MPI C compiler command
  F77         Fortran 77 compiler command
  FFLAGS      Fortran 77 compiler flags

为了用intel的编译器，我们需要特别指定一下：CC=icc F77=ifort，相关的参数通常保持默认即可。

备注： 1）如何查看CPU是否支持某个指令集呢？使用如下命令可以列出支持的指令集名称

cat /proc/cpuinfo | grep flags | uniq

2）SIMD SIMD单指令流多数据流(SingleInstructionMultiple Data,SIMD)是一种采用一个控制器来控制多个处理器，同时对一组数据（又称“数据向量”）中的每一个分别执行相同的操作从而实现空间上的并行性的技术。

MMX是由英特尔开发的一种SIMD多媒体指令集，SSE（Streaming SIMDExtensions）是MMX的扩充指令集，AVX（Advanced VectorExtensions）是Intel的SSE延伸架构，FMA（Fused MultiplyAccumulate）是Intel的AVX扩充指令集。

NEON实际上是ARM的SIMD（Single InstructionMultiple Data）技术的延续，它是一个结合64和128 bit的SIMD（Single InstructionMultiple Data 单指令多重数据）指令集。

2.3、优化编译单精度版本

# sigle
./configure --prefix=/public/home/ac30u77fum/rsfroot/mathlib/fftw-3.3.10 CC=gcc F77=gfortran MPICC=mpicc  --enable-shared --enable-static --enable-float --enable-see --enable-sse2 --enable-avx --enable-avx2 --enable-fma --enable-mpi --enable-threads --enable-openmp

make
make install

# double
./configure --prefix=/public/home/ac30u77fum/rsfroot/mathlib/fftw-3.3.10 CC=gcc F77=gfortran MPICC=mpicc  --enable-shared --enable-static --enable-see --enable-sse2 --enable-avx --enable-avx2 --enable-fma --enable-mpi --enable-threads --enable-openmp
make
make install

3、软件

通常会用到的是libfftw.a以及一些头文件，在编译或链接的时候，给出它的路径即可。

比如： gromacs软件：

  -DFFTWF_LIBRARY="$HOME/software/fftw/3.3.6-pl2-icc13"
  -DFFTWF_INCLUDE_DIR="$HOME/fftw/include/"

这里介绍的是官网题的fftw库，我们还可以使用Intel MKL库中的fftw接口。

环境变量：

Reference

fftw 编译安装教程 | 超算小站 (mrzhenggang.com)

Bash Shell 快捷键

Mon, 12 Dec 2022 00:00:00 GMT

Bash Shell 快捷键

在 Bash shell 中，熟记以下快捷键，将极大的提高你的命令行操作效率。

编辑命令

Ctrl + a ：移到命令行首

Ctrl + e ：移到命令行尾

Ctrl + f ：按字符前移（右向）

Ctrl + b ：按字符后移（左向）

Alt + f ：按单词前移（右向）

Alt + b ：按单词后移（左向）

Ctrl + xx：在命令行首和光标之间移动

Ctrl + u ：从光标处删除至命令行首

Ctrl + k ：从光标处删除至命令行尾

Ctrl + w ：从光标处删除至字首

Alt + d ：从光标处删除至字尾

Ctrl + d ：删除光标处的字符

Ctrl + h ：删除光标前的字符

Ctrl + y ：粘贴至光标后

Alt + c ：从光标处更改为首字母大写的单词

Alt + u ：从光标处更改为全部大写的单词

Alt + l ：从光标处更改为全部小写的单词

Ctrl + t ：交换光标处和之前的字符

Alt + t ：交换光标处和之前的单词

Alt + Backspace：与 Ctrl + w 相同类似，分隔符有些差别

Ctrl + c -- 取消当前行输入的命令，相当于Ctrl + Break。

Ctrl + s -- 暂停当前终端。

Ctrl + q -- 恢复当前终端。

Ctrl + z -- 后端运行。

Ctrl + l -- 清空屏幕并重新显示当前命令行内容

重新执行命令

Ctrl + r：逆向搜索命令历史

Ctrl + g：从历史搜索模式退出

Ctrl + p：历史中的上一条命令

Ctrl + n：历史中的下一条命令

Alt + .：使用上一条命令的最后一个参数

控制命令

Ctrl + l（L）：清屏

Ctrl + o：执行当前命令，并选择上一条命令

Ctrl + s：阻止屏幕输出

Ctrl + q：允许屏幕输出

Ctrl + c：终止命令

Ctrl + z：挂起命令

Bang (!) 命令

!!：执行上一条命令

!blah：执行最近的以 blah 开头的命令，如 !ls

!blah:p：仅打印输出，而不执行

!$：上一条命令的最后一个参数，与 Alt + . 相同

!*：上一条命令的所有参数

^blah：删除上一条命令中的 blah

^blah^foo：将上一条命令中的 blah 替换为 foo

^blah^foo^：将上一条命令中所有的 blah 都替换为 foo

Reference

【1】[让你提升命令行效率的 Bash 快捷键完整版] · LinuxTOY

环境变量和动态库、静态库配置

Sat, 12 Nov 2022 00:00:00 GMT

环境变量和动态库、静态库配置

1、环境变量

配置文件中添加环境变量 对所有用户有效修改/etc/profile /etc/bash.bashrc 对个人有效则修改~/.bashrc

在PATH中找到可执行文件程序的路径 export PATH =$PATH:$HOME/bin

2、C语言默认搜索路径

gcc找到头文件的路径

    C_INCLUDE_PATH=/usr/include/libxml2:/MyLib
    export C_INCLUDE_PATH

g++找到头文件的路径

    CPLUS_INCLUDE_PATH=$CPLUS_INCLUDE_PATH:/usr/include/libxml2:/MyLib
    export CPLUS_INCLUDE_PATH

找到动态链接库的路径

    LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/MyLib
    export LD_LIBRARY_PATH

找到静态库的路径

    LIBRARY_PATH=$LIBRARY_PATH:/MyLib
    export LIBRARY_PATH

3、gcc命令中手动设置搜索路径

添加头文件搜索路径

 gcc foo.c -I /home/xiaowp/include -o foo

添加动态库搜索路径（默认）

gcc foo.c -L /home/xiaowp/lib -lfoo -o foo

添加静态库搜索路径

gcc foo.c -L /home/xiaowp/lib -static -lfoo -o foo

Reference

【1】https://blog.csdn.net/sunxiaopengsun/article/details/74787966

MPI 并行指南

Wed, 12 Oct 2022 00:00:00 GMT

MPI 并行指南

MPI是一个跨平台的通信协议，用于编写并行计算机，支持点对点和广播。MPI是一个信息传递应用程序接口，包括协议和语义说明，他们指明其如何在各种实现中发挥其特性。MPI的目标是高性能，大规模性和可移植性。MPI在今天仍为高性能计算的主要模型。

MPI 是一个跨语言的通讯协议，用于编写并行计算机。支持点对点和广播。MPI 是一个信息传递应用程序接口，包括协议和和语义说明，他们指明其如何在各种实现中发挥其特性。MPI的目标是高性能，大规模性，和可移植性。MPI 在今天仍为高性能计算的主要模型。

MPI 可以大概分为两大类：Open MPI 和 MPICH 及其衍生。

MPICH 实现的比较全面，但是不支持 InfiniBand 这种比较新的硬件和协议。但是它的衍生品例如 Intel MPI 和 MVAPICH 支持比较新的硬件与协议。

Open MPI 也实现了 MPI 标准，并且应用广泛。它的进程管理比 MPICH 相对比较好。

Open MPI 与 OpenMP 是不同的概念。

1、Hello world 代码案例

让我们来看一下这节课的代码吧，完整的代码在 mpi_hello_world.c。下面是一些重点内容的摘录。

#include <mpi.h>
#include <stdio.h>

int main(int argc, char** argv) {
    // 初始化 MPI 环境
    MPI_Init(NULL, NULL);

    // 通过调用以下方法来得到所有可以工作的进程数量
    int world_size;
    MPI_Comm_size(MPI_COMM_WORLD, &world_size);

    // 得到当前进程的秩
    int world_rank;
    MPI_Comm_rank(MPI_COMM_WORLD, &world_rank);

    // 得到当前进程的名字
    char processor_name[MPI_MAX_PROCESSOR_NAME];
    int name_len;
    MPI_Get_processor_name(processor_name, &name_len);

    // 打印一条带有当前进程名字，秩以及
    // 整个 communicator 的大小的 hello world 消息。
    printf("Hello world from processor %s, rank %d out of %d processors\n",
           processor_name, world_rank, world_size);

    // 释放 MPI 的一些资源
    MPI_Finalize();
}

你应该已经注意到搭建一个 MPI 程序的第一步是引入 #include <mpi.h> 这个头文件。然后 MPI 环境必须以以下代码来初始化：

MPI_Init(int* argc, char*** argv)

在 MPI_Init 的过程中，所有 MPI 的全局变量或者内部变量都会被创建。举例来说，一个通讯器 communicator 会根据所有可用的进程被创建出来（进程是我们通过 mpi 运行时的参数指定的），然后每个进程会被分配独一无二的秩 rank。当前来说，MPI_Init 接受的两个参数是没有用处的，不过参数的位置保留着，可能以后的实现会需要用到。

在 MPI_Init 之后，有两个主要的函数被调用到了。这两个函数是几乎所有 MPI 程序都会用到的。

MPI_Comm_size(
    MPI_Comm communicator,
    int* size)

MPI_Comm_size 会返回 communicator 的大小，也就是 communicator 中可用的进程数量。在我们的例子中，MPI_COMM_WORLD（这个 communicator 是 MPI 帮我们生成的）这个变量包含了当前 MPI 任务中所有的进程，因此在我们的代码里的这个调用会返回所有的可用的进程数目。

MPI_Comm_rank( MPI_Comm communicator, int* rank)

MPI_Comm_rank 这个函数会返回 communicator 中当前进程的 rank。 communicator 中每个进程会以此得到一个从0开始递增的数字作为 rank 值。rank 值主要是用来指定发送或者接受信息时对应的进程。

我们代码中使用到的一个不太常见的方法是：

MPI_Get_processor_name( char* name, int* name_length)

MPI_Get_processor_name 会得到当前进程实际跑的时候所在的处理器名字。代码中最后一个调用是：

MPI_Finalize 是用来清理 MPI 环境的。这个调用之后就没有 MPI 函数可以被调用了。

2、运行 MPI hello world 程序

现在查看以下代码文件以及代码所在的文件夹，你会看到一个 makefile。

>>> git clone https://github.com/mpitutorial/mpitutorial
>>> cd mpitutorial/tutorials/mpi-hello-world/code
>>> cat makefile
EXECS=mpi_hello_world
MPICC?=mpicc

all: ${EXECS}

mpi_hello_world: mpi_hello_world.c
    ${MPICC} -o mpi_hello_world mpi_hello_world.c

clean:
    rm ${EXECS}

我的 makefile 会去找 MPICC 这个环境变量。如果你把 MPICH2 装在了本地文件夹里面而不是全局 PATH 下面, 手动设置一下 MPICC 这个环境变量，把它指向你的 mpicc 二进制程序。mpicc 二进制程序其实只是对 gcc 做了一层封装，使得编译和链接所有的 MPI 程序更方便。

>>> export MPICC=/home/kendall/bin/mpicc
>>> make
/home/kendall/bin/mpicc -o mpi_hello_world mpi_hello_world.c

当你的程序编译好之后，它就可以被执行了。不过执行之前你也许会需要一些额外配置。比如如果你想要在好几个节点的集群上面跑这个 MPI 程序的话，你需要配置一个 host 文件（不是 /etc/hosts）。如果你在笔记本或者单机上运行的话，可以跳过下面这一段。

需要配置的 host 文件会包含你想要运行的所有节点的名称。为了运行方便，你需要确认一下所有这些节点之间能通过 SSH 通信，并且需要根据设置认证文件这个教程配置不需要密码的 SSH 访问。我的 host 文件看起来像这样：

>>> cat host_file
cetus1
cetus2
cetus3
cetus4

为了用我提供的脚本来运行这个程序，你应该设置一个叫 MPI_HOSTS 的环境变量，把它指向 host 文件所在的位置。我的脚本会自动把这个 host 文件的配置项加到 MPI 启动命令里。如果单机跑的话就不用设置这个环境变量。另外如果你的 MPI 没有装到全局环境的话，你还需要指定 MPIRUN 这个环境变量指向你的 mpirun 二进制程序。

准备就绪之后你就可以使用这个项目的我提供的 python 脚本来执行程序。脚本在 tutorials 目录下面，这个脚本可以用来跑我们这个教程里面提到的所有程序（而且它会帮你先编译一下程序）。你可以在 mpitutorial 这个文件夹的根目录下执行以下命令：

>>> export MPIRUN=/home/kendall/bin/mpirun
>>> export MPI_HOSTS=host_file
>>> cd tutorials
>>> ./run.py mpi_hello_world
/home/kendall/bin/mpirun -n 4 -f host_file ./mpi_hello_world
Hello world from processor cetus2, rank 1 out of 4 processors
Hello world from processor cetus1, rank 0 out of 4 processors
Hello world from processor cetus4, rank 3 out of 4 processors
Hello world from processor cetus3, rank 2 out of 4 processors

跟预想的一样，这个 MPI 程序运行在了我提供的所有节点上面。每个进程都被分配了一个单独的 rank，跟进程的名字一起打印出来了。你可以看到，在我们的输出的结果里，进程之间的打印顺序是任意的，因为我们的代码里并没有涉及到同步的操作。

我们可以在打印的内容上面那条看到脚本是如何调用 mpirun 这个程序的。mpirun 是 MPI 的实现用来启动任务的一个程序。进程会在 host 文件里指定的所有机器上面生成，MPI 程序就会在所有进程上面运行。我的脚本自定地提供了一个 -n 参数告诉 MPI 程序我要运行 4 个进程。你可以试着修改脚本来使用更多进程运行 MPI 程序。当心别把你的操作系统玩崩了。:-)

你可能会问，“我的节点都都是双核的机器，我怎么样可以让 MPI 先在每个节点上的每个核上生成进程，再去其他的机器？” 其实方案很简单。修改一下你的 host 文件，在每个节点名字的后面加一个冒号和每个处理器有的核数就行了。比如，我在 host 文件里指定我的每个节点有2个核。

>>> cat host_file
cetus1:2
cetus2:2
cetus3:2
cetus4:2

当我再次运行我的脚本，哇!，MPI 任务只在我的两个节点上生成了4个进程。

>>> ./run.py mpi_hello_world
/home/kendall/bin/mpirun -n 4 -f host_file ./mpi_hello_world
Hello world from processor cetus1, rank 0 out of 4 processors
Hello world from processor cetus2, rank 2 out of 4 processors
Hello world from processor cetus2, rank 3 out of 4 processors
Hello world from processor cetus1, rank 1 out of 4 processors

3、进阶MPI编程

3.1、MPI初始化

#include "mpi.h"
#include <stdio.h>
int main(int argc, char* argv[])
{
//=========================================================
//  MPI Indix
//  =======================================================
    int myid,numprocs,namelen;
    char processor_name[MPI_MAX_PROCESSOR_NAME];
    // Basic MPI
    MPI_Init(&argc,&argv);
    MPI_Comm_rank(MPI_COMM_WORLD,&myid);               // rank id
    MPI_Comm_size(MPI_COMM_WORLD,&numprocs);           // total rank
    MPI_Get_processor_name(processor_name,&namelen);   // get the meachine name
    if(myid==0)
        printf("Number of MPI thread is %d\n",numprocs);
    MPI_Finalize();
}

在这段代码里，有几句比较重要：

MPI_Init(NULL, NULL) 在这一句之前，所有的进程都是完全相互独立的。
MPI_COMM_WORLD 是预定义好的通信器 (Communicator)，通信器是一个包含了进程的集合，同一个通信器里面的进程可以相互通信。
MPI_Comm_rank(MPI_COMM_WORLD, &world_rank) 获取每个进程的在通信器里面的 Rank，也就是编号
MPI_Finalize() 这一句释放掉所有被 MPI 占用的资源。
实际上 MPICC 的后端还是 GCC。MPICC 只是添加了动态链接库。

3.2、进程间通讯

3.2.1、P2P 接收与发送

MPI_Send 用来发送信息

MPI_Recv 用来接收信息

int MPI_Send(void *buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm);
int MPI_Recv(void *buf, int count, MPI_Datatype datatype, int source, int tag, MPI_Comm comm, MPI_Status *status);

参数说明

buf 内存地址，用于接收/发送消息的存储。
count 传送消息的数量
datatype 传输数据类型，除了 C 自带的类型以外，MPI 还定义了一些类型
dest 接收节点
source 发送节点
tag 信息的标签
comm 通信器
status 接收消息的状态

传递信息可以看作是一个 Message Envelope.每个 Send 要确保有对应的 Recv。除此以外，还要注意死锁问题，每个 Recv 都能即使获取到发送的东西。

值得一提的是，接收消息的长度跟发送消息的长度是可以不同的，但是最好保证接收消息的长度 大于等于 发送的长度，以免溢出。

#include <stdio.h>
#include <mpi.h>
#include <stdlib.h>

int main(int argc, char *argv[]) {
    MPI_Init(&argc, &argv);
    int numP, myId;
    MPI_Comm_rank(MPI_COMM_WORLD, &myId);
    MPI_Comm_size(MPI_COMM_WORLD, &numP);

    if(numP % 2 != 0) {
        if(!myId) {
            printf("ERROR: the number of ping-pong processors must be even number!\n");
        }
        MPI_Abort(MPI_COMM_WORLD, EXIT_FAILURE);
    }

    int partner_id;
    int odd = myId & 1;

    if(odd) {
        partner_id = myId - 1;
    } else {
        partner_id = myId + 1;
    }

    int a, b;
    if(odd == 0) {
        a = -1;
        printf("Process %d sends token %d to process %d\n", myId, a, partner_id);
        MPI_Send(&a, 1, MPI_INT, partner_id, 0, MPI_COMM_WORLD);

        MPI_Recv(&b, 1, MPI_INT, partner_id, 0, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
        printf("Process %d receives token %d from process %d\n", myId, b, partner_id);
    } else {
        a = 1;
        MPI_Recv(&b, 1, MPI_INT, partner_id, 0, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
        printf("Process %d receives token %d from process %d\n", myId, b, partner_id);

        printf("Process %d sends token %d to process %d\n", myId, a, partner_id);
        MPI_Send(&a, 1, MPI_INT, partner_id, 0, MPI_COMM_WORLD);
    }

    MPI_Finalize();
}

Result

Process 2 sends token -1 to process 3
Process 0 sends token -1 to process 1
Process 1 receives token -1 from process 0
Process 1 sends token 1 to process 0
Process 0 receives token 1 from process 1
Process 3 receives token -l from process 2
Process 3 sends token 1 to process 2
Process 2 receives token 1 from process 3

3.2.2 阻塞通信与非阻塞通信

刚才说的是阻塞通信，在发送出去/接收到之前，程序会停止运行。相对的，也存在非阻塞通信。如下：

MPI_ISend 用来发送信息

MPI_IRecv 用来接收信息

int MPI_ISend(void *buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm, MPI_Request *request);
int MPI_IRecv(void *buf, int count, MPI_Datatype datatype, int source, int tag, MPI_Comm comm, MPI_Request *request);

request 用于标记通信任务。在使用非阻塞通信传来的数据之前，需要使用 MPI_Wait 确认是否数据已经传入缓冲区。

非阻塞通信还有如下的控制与测试函数：

MPI_Cancel 用于取消非阻塞通信。
MPI_Test 用于测试非阻塞通信是否已经结束。
MPI_Wait 用于等待非阻塞通信数据。

#include <stdio.h>
#include <mpi.h>
#include <stdlib.h>

int main(int argc, char *argv[]) {
    MPI_Init(&argc, &argv);
    int numP, myId;
    MPI_Comm_rank(MPI_COMM_WORLD, &myId);
    MPI_Comm_size(MPI_COMM_WORLD, &numP);

    int next_id = (myId + 1) % numP, prev_id = (myId - 1 + numP) % numP;
    MPI_Request rq_send, rq_recv;

    int a = 1, b;
    MPI_Isend(&a, 1, MPI_INT, next_id, 0, MPI_COMM_WORLD, &rq_send);
    MPI_Irecv(&b, 1, MPI_INT, prev_id, 0, MPI_COMM_WORLD, &rq_recv);
    MPI_Wait(&rq_recv, MPI_STATUS_IGNORE);
    printf("%d receive token %d from %d\n" myId, b, prev_id);
    MPI_Barrier(MPI_COMM_WORLD);

    a = -1;
    MPI_Isend(&a, 1, MPI_INT, prev_id, 0, MPI_COMM_WORLD, &rq_send);
    MPI_Irecv(&b, 1, MPI_INT, next_id, 0, MPI_COMM_WORLD, &rq_recv);
    MPI_Wait(&rq_recv, MPI_STATUS_IGNORE);
    printf("%d receive token %d from %d\n" myId, b, next_id);
    MPI_Barrier(MPI_COMM_WORLD);

    MPI_Finalize();
}

结果

5 receive token 1 from 4
6 receive token 1 from 5
4 receive token 1 from 3
1 receive token 1 from 0
0 receive token 1 from 6
2 receive token 1 from 1
3 receive token 1 from 2
1 receive token -1 from 2
4 receive token -1 from 5
0 receive token -1 from 1
6 receive token -1 from 0
5 receive token -1 from 6
3 receive token -1 from 4
2 receive token -1 from 3

3.2.3 聚合通信 (Collective Communication)

除了点对点通信之外，MPI 还有其他的通信方式如图所示。

#include <stdio.h>
#include <mpi.h>
#include <stdlib.h>

int main(int argc, char *argv[]) {
    MPI_Init(&argc, &argv);
    int numP, myId;
    MPI_Comm_rank(MPI_COMM_WORLD, &myId);
    MPI_Comm_size(MPI_COMM_WORLD, &numP);

    int n = atoi(argv[1])
    MPI_Barrier(MPI_COMM_WORLD);

    double start = MPI_Wtime();

    int myCount = 0;
    int total;
    int prime;

    for(int i = 2 + myId; i <= n; i += numP) {
        prime = 1;
        for(int j = 2; j < i; ++j) {
            if(i % j == 0) {
                prime = 0;
                break;
            }
        }
        myCount += prime;
    }

    MPI_Reduce(&myCount, &total, 1, MPI_INT, MPI_SUM, 0, MPI_COMM_WORLD);

    double end = MPI_Wtime();
    if(!myId) {
        printf("%d primes between 1 and %d\n", total, n);
        printf("Time with %d processes: %.3lf seconds\n", numP, end - start);
    }
    MPI_Finalize();
}

MPI_Reduce 中有预定义好的 MPI_Ops 例如 MPI_MAX, MPI_SUM 等等。

mpirun -np 10 ./prime 100000

9592 primes between 1 and 100000
Time with 10 processes: 0.265 seconds

mpirun -np 1 ./prime 100000

9592 primes between 1 and 100000
Time with 1 processes: 1.012 seconds

Reference

【1】 https://mpitutorial.com/tutorials/mpi-hello-world/zh_cn/

【2】MPI Hello World · MPI Tutorial

【3】MPI编程入门(Fortran) (cndaqiang.github.io)

【4】cnblogs.com/zhangyazhou/p/13376262.html

【5】https://jinbridger.github.io/docs/hpc/openmpi-programming-101/

C和C++混编以及extern的用法

Mon, 12 Sep 2022 00:00:00 GMT

C和C++混编以及extern的用法

一. extern关键字

extern关键字的用法很简单，就是简简单单的声明，它可以明确的指出一个语句是声明；比如extern int i;那么就说明这是声明变量 i,而不是定义i,声明是不开辟内存的，定义是开辟内存的。假如int i；没有extern修饰，那就说明为定义，会分配内存空间的。

extern 的使用场景1

extern 可以声明一个变量，使得该变量是来自其他文件的变量在本文件可以被访问。

比如：创建两个文件 test.c 和 main.c文件；在test.c文件中定义一个全局变量：

//test.c
int i = 20; //定义一个全局变量

在main.c文件，声明变量 i;

main.c文件
# include<stdio.h>
extern int i; //声明变量i，当编译链接时候，main.c文件就可以访问到test.c文件的i的值了；
int main()
{
    printf("%d",i);
    return 0;
}

这样我们就可以跨文件（test.c），在本文件（main.c）访问这个变量了；

extern 的使用场景2

但是上诉的使用方式并不好，假如我一个大工程，这个工程由超级多的文件，这些文件假如都要访问 test.c文件的变量 i,那么，只能在这些文件中，每个文件的开头都声明变量 i,并且，假如我的test.c，不止一个定义一个变量i,有好多其他变量呢？在其他文件访问时候，都要声明好多变量，这会使得书写难度很繁琐，并且维护成本也大；

所以一般，我们都把声明语句放到头文件使用，即我定义一个test.h的头文件；在该头文件中，声明 extern int i；然后，假如你在其他文件要使用改变量i,直接包含该头文件即可，比如：test.h 头文件

//test.h 头文件
extern int i;
extern int j;
extern int k;
//...
//声明很多很多变量

在其他.c文件，只要包含该头文件，就可以啦，比如在main.c文件：

# include<stdio.h>
# include"test.h"
//extern int i; 不用写了
//extern int j;不用写了
//extern int k;不用写了
//...
//声明很多很多变量,都不用写了，因为包含了头文件，声明都在头文件中
int main()
{
    printf("%d %d %d",i,j,k);
    return 0;
}

extern的用法总结

extern一般用于声明，在.h文件中，声明变量或者函数（函数可以不加extern，但是最好加上，这样比较统一）；在其他文件要访问该变量函数时候，包含头文件就行哦。

二. extern “C” 的理解和用法

在C++中，extern"C"修饰的语句是按照C语言的方式进行编译的。

怎么理解这句话呢？

我来举几个例子：（理解它extern"C"的含义）我们知道在C++中函数是可以发生重载的，即编译的时候并不会报错,在C语言中，是没有重载的说法的;那么假如我用extern"C"去修饰重载的函数的话，即在编译时候，就会按照C语言的方式去编译了：这个时候，就会发生错误；看例子：创建一个main.cpp文件

# include<iostream>
using namespace std;

extern "C" void func() //用 extern"C"修饰
{
}
extern "C" void func(int v)//用 extern"C"修饰
{
}

int main()
{
    return 0;
}

看下面的报错信息，不允许重载啊，本来我C++文件就是可以重载的，但是用extern“C”修饰过后，就不可重载函数了，这就是按照C的编译方式编译，假如按C++编译方式编译那就是能通过的。

extern"C" 也是可以修饰声明函数的，也说明该函数时按照C语言的方式编译；

看看下面的例子：

# include<iostream>
using namespace std;

extern "C" void func() //用 extern"C"修饰
{
}
 void func(int v) //这个不用extern“C”声明
 {
 }
int main()
{
    return 0;
}

上面的情况不会报错，原因很简单：extern "C" void func() { }按C语言方式编译，这个不会错；void func(int v){ }按C++方式编译，所以也不会报错，这两者虽然函数名字相同，但是他们时按照不同的编译方式编译的，所以不报错；

extern"C "使用在C与C++混合开发中的使用方式

通常在C++ 中，假如需要使用C语言中的库文件的话，可以使用extern "C"去包含；

那如何使用呢？接下来我一步一步带你理解如何使用，先举几个例子。

比如：创建math.c（C文件）中，有一些函数是数学的加法和减法功能函数。我想在main.cpp文件中使用math.c文件中的函数，如何使用呢？第一种办法：在main.cpp文件用extern"C"包含math.c文件中的你想用的函数。

//math.c文件

int add (int x,int y)//加法
{
    return x+y;
}
int sub(int x,int y)//减法
{
    return x-y;
}
int mult(int x,int y)//乘法
{
    return x*y;
}
int div(int x,int y) //除法
{
    return x/y;
}

main.cpp（C++文件）中，要使用math.c文件中的函数.

//main.cpp文件
#include<iostream>
using namespace std;
extern “C” //用extern“C”{ }声明math.c文件中的函数，以至于可以在main.cpp文件使用。
{
    int add (int x,int y);
    int sub(int x,int y);
}

int main()
{
    cout<<add(10,20)<<endl; //由于有声明该函数，所以访问成功，结果30
    cout<<sub(10,20)<<endl;//由于有声明该函数，所以访问成功，结果-10
    return 0;
}

第二种使用方式：

假如我有一个需求，我想在main.cpp文件，用math.c文件中的其他函数，比如除法函数，乘法函数；那么我就只能在 main.cpp 中 extern"C"{ }的括号中，逐个的加上这两个函数；这好像也可以正常使用没问题，但是，这很麻烦啊，别人使用你的.c库时候会先得非常麻烦。所以我们一般使用头文件的方式，即创建多一个头文件math.h，在math.h里声明函数，在math.c文件定义函数，在main.cpp，即要使用该库文件里面，用extern"C"{ } ,在括号里包含该math.h头文件即可

看下math.h头文件内容：

// math.h文件的内容
int add (int x,int y);//加法
int sub(int x,int y);//减法
int mult(int x,int y);//乘法
int div(int x,int y); //除法

在math.c中定义函数

//math.c文件

int add (int x,int y)//加法
{
    return x+y;
}
int sub(int x,int y)//减法
{
    return x-y;
}
int mult(int x,int y)//乘法
{
    return x*y;
}
int div(int x,int y) //除法
{
    return x/y;
}

这时候我们只要在main.cpp文件中，用extern “C”{ }包含该头文件就可以使用了。

//main.cpp文件
#include<iostream>
using namespace std;

extern"C"{ //包含头文件，该里面是C语言方式编译的。
    # include"math.h"
}

int main()
{
    cout<<add(10,20)<<endl; //由于有声明该函数，所以访问成功，结果30
    cout<<sub(10,20)<<endl;//由于有声明该函数，所以访问成功，结果-10
    cout<<mutl(10,20)<<endl;
    cout<<div(10,20)<<endl;

    return 0;
}

这样就可以正常使用了。

但是，上面的使用方式还是不太好，该方式还是有一定的问题，什么问题呢？就是我在main.cpp文件使用extern "C"{ #include"math.h"} ,即要多写一个 extern"C"{ },显得格外麻烦，再说了，假如还有其他Cpp文件要用这个C语言的库呢。都是这种方式，extern"C"太麻烦啦。我们之前都是直接#include"math.h",这样才是我们平时的使用习惯呢。

所以有了这第三种使用方式：（为的是直接在main.cpp中，#include"math.h"就可以使用，不用多谢extern"C"）

直接在math.h中，用extern"C"的方式修饰就行啦。那么我就可以在main.cpp直接#include"math.h"。 (代码就不写啦，文字可以理解就行)

上面的使用有并不是完全好的方式，如何说呢？假如我有一个.c文件，创建为other.c，我这个文件呢，也想使用math.c的函数，那么我就可以在other.c文件直接包含该math.c文件就可以了，可是事实却不如所想，这样会报错，报错的原因是，由于在math.h文件中，声明函数用了extern"C"，而other.c文件# include"math.h"，会包含里面的所有内容，包括里面的 extern"C", 这个extern"C"在other.c文件，即C语言文件是不认识extern"C"啊,所以会报错

下面展示报错的代码，创建other.c文件（C文件），里面包含math.h文件(该文件有extern"C"{ }声明方式 )

//other.c文件
# include"math.h"
//包含头文件，由于这是.c文件，不是.cpp文件。所以.c文件不认识extern"C",所以会报错

void test()
{
    int ret = add(10,20);//报错，不认识，add.
}

所以如何解决上面问题呢？核心问题是，我希望有一种使用 extern"C"的方式，在C语言文件中，能够使用该库，在C++文件中也可以使用该库。

要解决这个问题：也是 第四种使用方式

由于编译器默认会在，你创建的任何一个.cpp文件中，默认定义一个宏 #define __cplusplus,这个宏是你看不到的，是编译器默认给每个.cpp文件创建的，而在.c文件，即C语言的编译器，是没有这个宏的，所以我们可以借助它，来在 math.h文件中使用下面的代码：

看math.h的代码

// math.h文件的内容

//意思是如果使用该头文件math.h的文件定义了__cplusplus，
//则下面代码到#endif都是有效的,在这里是 extern "C" { 有效
#ifdef __cplusplus
extern "C" {
#endif  //__cplusplus

int add (int x,int y);//加法
int sub(int x,int y);//减法
int mult(int x,int y);//乘法
int div(int x,int y); //除法

//意思是如果使用该头文件math.h的文件定义了__cplusplus，
//则下面代码到#endif都是有效的,在这里是 } 有效
#ifdef __cplusplus
}
#endif  //__cplusplus

在main.cpp文件你直接包含该头文件math.h就可以使用了；在other.c文件中你直接包含该头文件math.h就可以使用了；

只要按上面的方式书写，那么就可以完美的解决了在C文件和C++文件中混用的问题；你既可以在.c文件使用该头文件，也可以在.cpp文件中使用该文件库。

第四种方式是最值得推荐的。

三. 总结

两者 extern 和 extern"C"有点区别：

extren 在C和C++中，都表示声明语句的意思；

而 extern"C"是按C语言方式去编译文件；

extern"C"只能在C++文件使用，extern在C和C++都可以使用；

Reference

https://blog.csdn.net/m0_46606290/article/details/119973574

动态库、静态库编译、打包

Tue, 12 Jul 2022 00:00:00 GMT

动态库、静态库编译、打包

1、头文件守卫

防止头文件被重复包含

#ifndef _HEAD_H_
#define _HEAD_H_
......
#endif

2、静态库的制作打包

将 .c 生成 .o 文件

gcc -c add.c -o add.o

使用 ar 工具制作静态库

ar rcs lib库名.a add.o sub.o div.o

编译静态库到可执行文件中：

gcc test.c lib库名.a -o a.out

4. 如果您的库依赖于其他静态库，您需要在这一步之前将所有依赖的库合并到您的库中。这可以通过使用 ld 工具的 --whole-archive 选项来实现，例如：

gcc -static -Wl,--whole-archive libdependency.a -Wl,--no-whole-archive -o libyourlibrary.a yourlibrary.o

这个命令会将 libdependency.a 中的所有对象文件与 yourlibrary.o 合并成一个静态libyourlibrary.a。打包共享：将您的静态库 libyourlibrary.a 以及所有相关的头文件和文档打包，确保依赖库的版权和许可信息也被包含在内。

在GCC中使用-Wl,--whole-archive选项，可以告诉链接器（通常是ld）将后续的静态库中的所有对象文件都包含进最终的可执行文件中，而不是只包含被引用的对象文件。这在创建包含多个库的静态链接的可执行文件时非常有用。例如，如果您有两个静态库libA.a和libB.a，并且您想要确保这两个库中的所有对象文件都被包含进最终的可执行文件中，即使libB.a中的某些对象文件没有被libA.a直接引用，您可以使用以下命令：

gcc -o my_program my_program.o -Wl,--whole-archive libA.a libB.a -Wl,--no-whole-archive

在这个例子中，-Wl,--whole-archive选项告诉链接器包含libA.a和libB.a中的所有对象文件，而-Wl,--no-whole-archive选项则关闭了这个行为，确保后续的库只包含被引用的对象文件。

请注意，-Wl选项是GCC的一个前缀，用于将后面的选项传递给链接器。因此，-Wl,--whole-archive实际上是在告诉GCC将--whole-archive选项传递给链接器ld。同样地，-Wl,--no-whole-archive告诉链接器停止--whole-archive行为。

使用--whole-archive时，需要谨慎，因为这将增加最终可执行文件的大小，并且可能会包含不必要的代码。此外，如果多个库中存在相同的符号定义，可能会导致链接时的问题。

3、动态库的制作打包

将 .c 生成 .o 文件，（生成与位置无关的代码 -fPIC）

gcc -c add.c -o add.o -fPIC

使用 gcc -shared 制作动态库

gcc -shared -o lib库名.so    add.o sub.o div.o

编译可执行程序时，指定所使用的动态库。 -l：指定库名(去掉lib前缀和.so后缀) -L：指定库路径。

gcc test.c -o a.out -lmymath -L./lib

运行可以执行程序 ./a.out 出错！！！！

--- ldd a.out --> "not found" error while loading shared libraries: libxxx.so: cannot open shared object file: No such file or directory

例如，如果你有一个共享库位于/usr/local/lib目录，并且你想要编译的程序在运行时能够找到这个库，你可以使用如下的gcc命令显示指定动态库的搜索动态库路径

gcc -o my_program my_program.c -L/usr/local/lib -lmylib -Wl,-rpath,/usr/local/lib

这里，-L/usr/local/lib告诉编译器在编译时到哪里查找库，而-Wl,-rpath,/usr/local/lib则告诉链接器在运行时到哪里查找这个库。

需要注意的是，-rpath选项的用法可能因不同的系统和链接器而有所不同，上面的例子适用于使用GNU ld链接器的情况。在有些系统上，可能需要使用不同的选项或者不同的方式来指定运行时链接路径。

原因：

链接器：工作于链接阶段，工作时需要 -l 和 -L

动态链接器：工作于程序运行阶段，工作时需要提供动态库所在目录位置。

解决方式：

【1】通过环境变量： export LD_LIBRARY_PATH=动态库路径

./a.out 成功！！！（临时生效，终端重启环境变量失效）

【2】永久生效：写入终端配置文件。 .bashrc 建议使用绝对路径。

【3】拷贝自定义动态库到 /lib (标准C库所在目录位置)

【4】配置文件法

sudo vi /etc/ld.so.conf

sudo ldconfig -v 使配置文件生效。

4）./a.out 成功

4、复杂的打包实例

include ./Makefile.config

SRCS=$(wildcard *.c)
OBJS_static=$(patsubst %.c, %.o, $(SRCS))
OBJS_dynamic=$(patsubst %.c, %.os, $(SRCS))
install:install_static install_dynamic
        cp rsf.h $(LGLROOT)/include/
        cp librsf.a $(LGLROOT)/lib/
        cp libdrsf.so $(LGLROOT)/lib/
install_static:$(OBJS_static)
        ar rc librsf.a $^
        ranlib librsf.a

install_dynamic:$(OBJS_dynamic)
        $(CC) -o libdrsf.so  -fopenmp -shared $^ -lm -lblas -lcblas

%.os:%.c
        $(CC) -o $@ -c -g -x c  -Wall  -fopenmp -fPIC -DRSF_VERSION='"4.0"' $<
%.o:%.c
        $(CC) -o $@ -c -g -x c  -Wall -fopenmp -DRSF_VERSION='"4.0"'  $<

clean:
        -rm -rf *.o *.os  librsf.a libdrsf.so
realclean:clean
        -rm -rf $(LGLROOT)/include/rsf.h $(LGLROOT)/lib/librsf.a $(LGLROOT)/lib/libdrsf.so

磁盘DISK速率查看

Sun, 12 Jun 2022 00:00:00 GMT

磁盘DISK速率查看

1、安装软件

sudo apt-get install iotop

2、开启另一个终端窗口，使用cp命令复制一个大文件

cp -R xx  xx2   # 递归复制文件夹到

3、查看iotop (sometimes: sudo)

Reference

【1】在linux终端显示cp命令复制文件时的速度_linux_叫我蔡大叔-华为云开发者联盟 (csdn.net)

Fortran 命令行参数

Sun, 12 Jun 2022 00:00:00 GMT

Fortran 命令行参数

1、实例

CALL get_command_argument(1,FN1)
CALL get_command_argument(2,FN3)

用上面两行代替下面：

!FN1=1201-201-1.rsf@'
!FN3='./PML/sh0t_pml-1.rsf@'

注意此处FN1，FN3 为字符串

Reference

【1】科学网—【Fortran】Fortran程序带参数运行方法总结 - 郑晖的博文 (sciencenet.cn)

CMake 基本用法与简单介绍

Sun, 12 Jun 2022 00:00:00 GMT

CMake 基本用法与简单介绍

1、基本介绍

CMake 是一个项目构建工具，并且是跨平台的。关于项目构建我们所熟知的还有Makefile（通过 make 命令进行项目的构建），大多是IDE软件都集成了make，比如：VS 的 nmake、linux 下的 GNU make、Qt 的 qmake等，如果自己动手写 makefile，会发现，makefile 通常依赖于当前的编译平台，而且编写 makefile 的工作量比较大，解决依赖关系时也容易出错。

而 CMake 恰好能解决上述问题，其允许开发者指定整个工程的编译流程，在根据编译平台，自动生成本地化的Makefile和工程文件，最后用户只需make编译即可，所以可以把CMake看成一款自动生成 Makefile的工具，其编译流程如下图：

蓝色虚线表示使用makefile构建项目的过程
红色实线表示使用cmake构建项目的过程

介绍完CMake的作用之后，再来总结一下它的优点：

跨平台
能够管理大型项目
简化编译构建过程和编译过程
可扩展：可以为 cmake 编写特定功能的模块，扩充 cmake 功能

2. CMake的使用

CMake支持大写、小写、混合大小写的命令。如果在编写CMakeLists.txt文件时使用的工具有对应的命令提示，那么大小写随缘即可，不要太过在意。

2.1 注释

2.1.1 注释行

CMake 使用 # 进行行注释，可以放在任何位置。

cmake_minimum_required(VERSION 3.0.0)

2.1.2 注释块

CMake 使用 #[[ ]] 形式进行块注释。

cmake_minimum_required(VERSION 3.0.0)

2.1 只有源文件

2.1.1 共处一室

准备工作，为了方便测试，在我本地电脑准备了这么几个测试文件

add.c

#include <stdio.h>
#include "head.h"

int add(int a, int b)
{
    return a+b;
}

sub.c

#include <stdio.h>
#include "head.h"


int subtract(int a, int b)
{
    return a-b;
}

mult.c

#include <stdio.h>
#include "head.h"

int multiply(int a, int b)
{
    return a*b;
}

div.c

#include <stdio.h>
#include "head.h"

double divide(int a, int b)
{
    return (double)a/b;
}

head.h

#ifndef _HEAD_H
#define _HEAD_H

int add(int a, int b);

int subtract(int a, int b);

int multiply(int a, int b);

double divide(int a, int b);
#endif

main.c

#include <stdio.h>
#include "head.h"

int main()
{
    int a = 20;
    int b = 12;
    printf("a = %d, b = %d\n", a, b);
    printf("a + b = %d\n", add(a, b));
    printf("a - b = %d\n", subtract(a, b));
    printf("a * b = %d\n", multiply(a, b));
    printf("a / b = %f\n", divide(a, b));
    return 0;
}

上述文件的目录结构如下：

$ tree
.
├── add.c
├── div.c
├── head.h
├── main.c
├── mult.c
└── sub.c

添加 CMakeLists.txt 文件

在上述源文件所在目录下添加一个新文件 CMakeLists.txt，文件内容如下：
```
cmake_minimum_required(VERSION 3.0)
project(CALC)
add_executable(app add.c div.c main.c mult.c sub.c)
```
接下来依次介绍一下在 CMakeLists.txt 文件中添加的三个命令:
- cmake_minimum_required：指定使用的 cmake 的最低版本
  - 可选，非必须，如果不加可能会有警告
- project：定义工程名称，并可指定工程的版本、工程描述、web主页地址、支持的语言（默认情况支持所有语言），如果不需要这些都是可以忽略的，只需要指定出工程名字即可。
```
project(<PROJECT-NAME> [<language-name>...])
project(<PROJECT-NAME>
       [VERSION <major>[.<minor>[.<patch>[.<tweak>]]]]
       [DESCRIPTION <project-description-string>]
       [HOMEPAGE_URL <url-string>]
       [LANGUAGES <language-name>...])
```
- add_executable：定义工程会生成一个可执行程序
```
add_executable(可执行程序名 源文件名称)
```
  - 这里的可执行程序名和project中的项目名没有任何关系
  - 源文件名可以是一个也可以是多个，如有多个可用空格或;间隔
```
add_executable(app add.c div.c main.c mult.c sub.c)

add_executable(app add.c;div.c;main.c;mult.c;sub.c)
```

执行CMake 命令

万事俱备只欠东风，将 CMakeLists.txt 文件编辑好之后，就可以执行 cmake命令了。

# cmake 命令原型
$ cmake CMakeLists.txt文件所在路径

$ tree
.
├── add.c
├── CMakeLists.txt
├── div.c
├── head.h
├── main.c
├── mult.c
└── sub.c

0 directories, 7 files
robin@OS:~/Linux/3Day/calc$ cmake .

当执行cmake命令之后，CMakeLists.txt 中的命令就会被执行，所以一定要注意给cmake 命令指定路径的时候一定不能出错。

执行命令之后，看一下源文件所在目录中是否多了一些文件：

$ tree -L 1
.
├── add.c
├── CMakeCache.txt         # new add file
├── CMakeFiles             # new add dir
├── cmake_install.cmake    # new add file
├── CMakeLists.txt
├── div.c
├── head.h
├── main.c
├── Makefile               # new add file
├── mult.c
└── sub.c

我们可以看到在对应的目录下生成了一个makefile文件，此时再执行make命令，就可以对项目进行构建得到所需的可执行程序了。

$ make
Scanning dependencies of target app
[ 16%] Building C object CMakeFiles/app.dir/add.c.o
[ 33%] Building C object CMakeFiles/app.dir/div.c.o
[ 50%] Building C object CMakeFiles/app.dir/main.c.o
[ 66%] Building C object CMakeFiles/app.dir/mult.c.o
[ 83%] Building C object CMakeFiles/app.dir/sub.c.o
[100%] Linking C executable app
[100%] Built target app

# 查看可执行程序是否已经生成
$ tree -L 1
.
├── add.c
├── app					# 生成的可执行程序
├── CMakeCache.txt
├── CMakeFiles
├── cmake_install.cmake
├── CMakeLists.txt
├── div.c
├── head.h
├── main.c
├── Makefile
├── mult.c
└── sub.c

最终可执行程序app就被编译出来了（这个名字是在CMakeLists.txt中指定的）。

2.1.2 VIP 包房

通过上面的例子可以看出，如果在CMakeLists.txt文件所在目录执行了cmake命令之后就会生成一些目录和文件（包括 makefile 文件），如果再基于makefile文件执行make命令，程序在编译过程中还会生成一些中间文件和一个可执行文件，这样会导致整个项目目录看起来很混乱，不太容易管理和维护，此时我们就可以把生成的这些与项目源码无关的文件统一放到一个对应的目录里边，比如将这个目录命名为build:

$ mkdir build
$ cd build
$ cmake ..
-- The C compiler identification is GNU 5.4.0
-- The CXX compiler identification is GNU 5.4.0
-- Check for working C compiler: /usr/bin/cc
-- Check for working C compiler: /usr/bin/cc -- works
-- Detecting C compiler ABI info
-- Detecting C compiler ABI info - done
-- Detecting C compile features
-- Detecting C compile features - done
-- Check for working CXX compiler: /usr/bin/c++
-- Check for working CXX compiler: /usr/bin/c++ -- works
-- Detecting CXX compiler ABI info
-- Detecting CXX compiler ABI info - done
-- Detecting CXX compile features
-- Detecting CXX compile features - done
-- Configuring done
-- Generating done
-- Build files have been written to: /home/robin/Linux/build

现在cmake命令是在build目录中执行的，但是CMakeLists.txt文件是build目录的上一级目录中，所以cmake 命令后指定的路径为..，即当前目录的上一级目录。

当命令执行完毕之后，在build目录中会生成一个makefile文件

$ tree build -L 1
build
├── CMakeCache.txt
├── CMakeFiles
├── cmake_install.cmake
└── Makefile

1 directory, 3 files

这样就可以在build目录中执行make命令编译项目，生成的相关文件自然也就被存储到build目录中了。这样通过cmake和make生成的所有文件就全部和项目源文件隔离开了，各回各家，各找各妈。

2.2 私人订制

2.2.1 定义变量

在上面的例子中一共提供了5个源文件，假设这五个源文件需要反复被使用，每次都直接将它们的名字写出来确实是很麻烦，此时我们就需要定义一个变量，将文件名对应的字符串存储起来，在cmake里定义变量需要使用set。

SET(VAR [VALUE] [CACHE TYPE DOCSTRING [FORCE]])

VAR：变量名
VALUE：变量值

set(SRC_LIST add.c;div.c;main.c;mult.c;sub.c)
add_executable(app  ${SRC_LIST})

2.2.2 指定使用的C++标准

在编写C++程序的时候，可能会用到C++11、C++14、C++17、C++20等新特性，那么就需要在编译的时候在编译命令中制定出要使用哪个标准：

$ g++ *.cpp -std=c++11 -o app

上面的例子中通过参数-std=c++11指定出要使用c++11标准编译程序，C++标准对应有一宏叫做DCMAKE_CXX_STANDARD。在CMake中想要指定C++标准有两种方式：

在 CMakeLists.txt 中通过 set 命令指定

set(CMAKE_CXX_STANDARD 11)

set(CMAKE_CXX_STANDARD 14)

set(CMAKE_CXX_STANDARD 17)

在执行 cmake 命令的时候指定出这个宏的值

#增加-std=c++11
cmake CMakeLists.txt文件路径 -DCMAKE_CXX_STANDARD=11
#增加-std=c++14
cmake CMakeLists.txt文件路径 -DCMAKE_CXX_STANDARD=14
#增加-std=c++17
cmake CMakeLists.txt文件路径 -DCMAKE_CXX_STANDARD=17

在上面例子中 CMake 后的路径需要根据实际情况酌情修改。

2.2.3 指定输出的路径

在CMake中指定可执行程序输出的路径，也对应一个宏，叫做EXECUTABLE_OUTPUT_PATH，它的值还是通过set命令进行设置:

set(HOME /home/robin/Linux/Sort)
set(EXECUTABLE_OUTPUT_PATH ${HOME}/bin)

第一行：定义一个变量用于存储一个绝对路径
第二行：将拼接好的路径值设置给EXECUTABLE_OUTPUT_PATH宏
- 如果这个路径中的子目录不存在，会自动生成，无需自己手动创建

由于可执行程序是基于 cmake 命令生成的 makefile 文件然后再执行 make 命令得到的，所以如果此处指定可执行程序生成路径的时候使用的是相对路径 ./xxx/xxx，那么这个路径中的 ./ 对应的就是 makefile 文件所在的那个目录。

2.3 搜索文件

如果一个项目里边的源文件很多，在编写CMakeLists.txt文件的时候不可能将项目目录的各个文件一一罗列出来，这样太麻烦也不现实。所以，在CMake中为我们提供了搜索文件的命令，可以使用aux_source_directory命令或者file命令。

2.3.1 方式1

在 CMake 中使用aux_source_directory 命令可以查找某个路径下的所有源文件，命令格式为：

aux_source_directory(< dir > < variable >)

dir：要搜索的目录
variable：将从dir目录下搜索到的源文件列表存储到该变量中

cmake_minimum_required(VERSION 3.0)
project(CALC)
include_directories(${PROJECT_SOURCE_DIR}/include)

aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR}/src SRC_LIST)
add_executable(app  ${SRC_LIST})

2.3.2 方式2

如果一个项目里边的源文件很多，在编写CMakeLists.txt文件的时候不可能将项目目录的各个文件一一罗列出来，这样太麻烦了。所以，在CMake中为我们提供了搜索文件的命令，他就是file（当然，除了搜索以外通过 file 还可以做其他事情）。

file(GLOB/GLOB_RECURSE 变量名 要搜索的文件路径和文件类型)

GLOB: 将指定目录下搜索到的满足条件的所有文件名生成一个列表，并将其存储到变量中。
GLOB_RECURSE：递归搜索指定目录，将搜索到的满足条件的文件名生成一个列表，并将其存储到变量中。

搜索当前目录的src目录下所有的源文件，并存储到变量中

file(GLOB MAIN_SRC ${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp)
file(GLOB MAIN_HEAD ${CMAKE_CURRENT_SOURCE_DIR}/include/*.h)

CMAKE_CURRENT_SOURCE_DIR 宏表示当前访问的 CMakeLists.txt 文件所在的路径。
关于要搜索的文件路径和类型可加双引号，也可不加:
```
file(GLOB MAIN_HEAD "${CMAKE_CURRENT_SOURCE_DIR}/src/*.h")
```

2.4 包含头文件

在编译项目源文件的时候，很多时候都需要将源文件对应的头文件路径指定出来，这样才能保证在编译过程中编译器能够找到这些头文件，并顺利通过编译。在CMake中设置要包含的目录也很简单，通过一个命令就可以搞定了，他就是include_directories:

include_directories(headpath)

举例说明，有源文件若干，其目录结构如下：

$ tree
.
├── build
├── CMakeLists.txt
├── include
│   └── head.h
└── src
    ├── add.cpp
    ├── div.cpp
    ├── main.cpp
    ├── mult.cpp
    └── sub.cpp

3 directories, 7 files

CMakeLists.txt文件内容如下:

cmake_minimum_required(VERSION 3.0)
project(CALC)
set(CMAKE_CXX_STANDARD 11)
set(HOME /home/robin/Linux/calc)
set(EXECUTABLE_OUTPUT_PATH ${HOME}/bin/)
include_directories(${PROJECT_SOURCE_DIR}/include)
file(GLOB SRC_LIST ${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp)
add_executable(app  ${SRC_LIST})

其中，第六行指定就是头文件的路径，PROJECT_SOURCE_DIR宏对应的值就是我们在使用cmake命令时，后面紧跟的目录，一般是工程的根目录。

2.5 制作动态库或静态库

有些时候我们编写的源代码并不需要将他们编译生成可执行程序，而是生成一些静态库或动态库提供给第三方使用，下面来讲解在cmake中生成这两类库文件的方法。

2.5.1 制作静态库

在cmake中，如果要制作静态库，需要使用的命令如下：

add_library(库名称 STATIC 源文件1 [源文件2] ...)

在Linux中，静态库名字分为三部分：lib+库名字+.a，此处只需要指定出库的名字就可以了，另外两部分在生成该文件的时候会自动填充。

在Windows中虽然库名和Linux格式不同，但也只需指定出名字即可。

下面有一个目录，需要将src目录中的源文件编译成静态库，然后再使用：

.
├── build
├── CMakeLists.txt
├── include           # 头文件目录
│   └── head.h
├── main.cpp          # 用于测试的源文件
└── src               # 源文件目录
    ├── add.cpp
    ├── div.cpp
    ├── mult.cpp
    └── sub.cpp

根据上面的目录结构，可以这样编写CMakeLists.txt文件:

cmake_minimum_required(VERSION 3.0)
project(CALC)
include_directories(${PROJECT_SOURCE_DIR}/include)
file(GLOB SRC_LIST "${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp")
add_library(calc STATIC ${SRC_LIST})

这样最终就会生成对应的静态库文件libcalc.a。

2.5.2 制作动态库

在cmake中，如果要制作动态库，需要使用的命令如下：

add_library(库名称 SHARED 源文件1 [源文件2] ...)

在Linux中，动态库名字分为三部分：lib+库名字+.so，此处只需要指定出库的名字就可以了，另外两部分在生成该文件的时候会自动填充。

在Windows中虽然库名和Linux格式不同，但也只需指定出名字即可。

根据上面的目录结构，可以这样编写CMakeLists.txt文件:

cmake_minimum_required(VERSION 3.0)
project(CALC)
include_directories(${PROJECT_SOURCE_DIR}/include)
file(GLOB SRC_LIST "${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp")
add_library(calc SHARED ${SRC_LIST})

这样最终就会生成对应的动态库文件libcalc.so。

2.5.3 指定输出的路径

方式1 - 适用于动态库

对于生成的库文件来说和可执行程序一样都可以指定输出路径。由于在Linux下生成的动态库默认是有执行权限的，所以可以按照生成可执行程序的方式去指定它生成的目录：

cmake_minimum_required(VERSION 3.0)
project(CALC)
include_directories(${PROJECT_SOURCE_DIR}/include)
file(GLOB SRC_LIST "${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp")

set(EXECUTABLE_OUTPUT_PATH ${PROJECT_SOURCE_DIR}/lib)
add_library(calc SHARED ${SRC_LIST})

对于这种方式来说，其实就是通过set命令给EXECUTABLE_OUTPUT_PATH宏设置了一个路径，这个路径就是可执行文件生成的路径。

方式2 - 都适用

由于在Linux下生成的静态库默认不具有可执行权限，所以在指定静态库生成的路径的时候就不能使用EXECUTABLE_OUTPUT_PATH宏了，而应该使用LIBRARY_OUTPUT_PATH，这个宏对应静态库文件和动态库文件都适用。

cmake_minimum_required(VERSION 3.0)
project(CALC)
include_directories(${PROJECT_SOURCE_DIR}/include)
file(GLOB SRC_LIST "${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp")

set(LIBRARY_OUTPUT_PATH ${PROJECT_SOURCE_DIR}/lib)



add_library(calc STATIC ${SRC_LIST})

2.6 包含库文件

在编写程序的过程中，可能会用到一些系统提供的动态库或者自己制作出的动态库或者静态库文件，cmake中也为我们提供了相关的加载动态库的命令。

2.6.1 链接静态库

src
├── add.cpp
├── div.cpp
├── main.cpp
├── mult.cpp
└── sub.cpp

现在我们把上面src目录中的add.cpp、div.cpp、mult.cpp、sub.cpp编译成一个静态库文件libcalc.a。通过命令制作并使用静态链接库

测试目录结构如下：

$ tree
.
├── build
├── CMakeLists.txt
├── include
│   └── head.h
├── lib
│   └── libcalc.a     # 制作出的静态库的名字
└── src
    └── main.cpp

4 directories, 4 files

在cmake中，链接静态库的命令如下：

link_libraries(<static lib> [<static lib>...])

参数1：指定出要链接的静态库的名字
- 可以是全名 libxxx.a
- 也可以是掐头（lib）去尾（.a）之后的名字 xxx
参数2-N：要链接的其它静态库的名字

如果该静态库不是系统提供的（自己制作或者使用第三方提供的静态库）可能出现静态库找不到的情况，此时可以将静态库的路径也指定出来：

link_directories(<lib path>)

这样，修改之后的CMakeLists.txt文件内容如下:

cmake_minimum_required(VERSION 3.0)
project(CALC)

file(GLOB SRC_LIST ${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp)

include_directories(${PROJECT_SOURCE_DIR}/include)

link_directories(${PROJECT_SOURCE_DIR}/lib)

link_libraries(calc)
add_executable(app ${SRC_LIST})

添加了第8行的代码，就可以根据参数指定的路径找到这个静态库了。

2.6.2 链接动态库

在程序编写过程中，除了在项目中引入静态库，好多时候也会使用一些标准的或者第三方提供的一些动态库，关于动态库的制作、使用以及在内存中的加载方式和静态库都是不同的，在此不再过多赘述，如有疑惑请参考Linux 静态库和动态库

在cmake中链接动态库的命令如下:

target_link_libraries(
    <target>
    <PRIVATE|PUBLIC|INTERFACE> <item>...
    [<PRIVATE|PUBLIC|INTERFACE> <item>...]...)

target：指定要加载动态库的文件的名字
- 该文件可能是一个源文件
- 该文件可能是一个动态库文件
- 该文件可能是一个可执行文件
PRIVATE|PUBLIC|INTERFACE：动态库的访问权限，默认为PUBLIC
- 如果各个动态库之间没有依赖关系，无需做任何设置，三者没有没有区别，一般无需指定，使用默认的 PUBLIC 即可。
- 动态库的链接具有传递性，如果动态库 A 链接了动态库B、C，动态库D链接了动态库A，此时动态库D相当于也链接了动态库B、C，并可以使用动态库B、C中定义的方法。
```
target_link_libraries(A B C)
target_link_libraries(D A)
```
  - PUBLIC：在public后面的库会被Link到前面的target中，并且里面的符号也会被导出，提供给第三方使用。
  - PRIVATE：在private后面的库仅被link到前面的target中，并且终结掉，第三方不能感知你调了啥库
  - INTERFACE：在interface后面引入的库不会被链接到前面的target中，只会导出符号。

链接系统动态库

动态库的链接和静态库是完全不同的：

静态库会在生成可执行程序的链接阶段被打包到可执行程序中，所以可执行程序启动，静态库就被加载到内存中了。
动态库在生成可执行程序的链接阶段不会被打包到可执行程序中，当可执行程序被启动并且调用了动态库中的函数的时候，动态库才会被加载到内存

因此，在cmake中指定要链接的动态库的时候，应该将命令写到生成了可执行文件之后：

cmake_minimum_required(VERSION 3.0)
project(TEST)
file(GLOB SRC_LIST ${CMAKE_CURRENT_SOURCE_DIR}/*.cpp)

add_executable(app ${SRC_LIST})

target_link_libraries(app pthread)

在target_link_libraries(app pthread)中：

app: 对应的是最终生成的可执行程序的名字
pthread：这是可执行程序要加载的动态库，这个库是系统提供的线程库，全名为libpthread.so，在指定的时候一般会掐头（lib）去尾（.so）。

链接第三方动态库

现在，自己生成了一个动态库，对应的目录结构如下：

$ tree
.
├── build
├── CMakeLists.txt
├── include
│   └── head.h            # 动态库对应的头文件
├── lib
│   └── libcalc.so        # 自己制作的动态库文件
└── main.cpp              # 测试用的源文件

3 directories, 4 files

假设在测试文件main.cpp中既使用了自己制作的动态库libcalc.so又使用了系统提供的线程库，此时CMakeLists.txt文件可以这样写：

cmake_minimum_required(VERSION 3.0)
project(TEST)
file(GLOB SRC_LIST ${CMAKE_CURRENT_SOURCE_DIR}/*.cpp)
include_directories(${PROJECT_SOURCE_DIR}/include)
add_executable(app ${SRC_LIST})
target_link_libraries(app pthread calc)

在第六行中，pthread、calc都是可执行程序app要链接的动态库的名字。当可执行程序app生成之后并执行该文件，会提示有如下错误信息：

$ ./app
./app: error while loading shared libraries: libcalc.so: cannot open shared object file: No such file or directory

这是因为可执行程序启动之后，去加载calc这个动态库，但是不知道这个动态库被放到了什么位置解决动态库无法加载的问题，所以就加载失败了，在 CMake 中可以在生成可执行程序之前，通过命令指定出要链接的动态库的位置，指定静态库位置使用的也是这个命令：

link_directories(path)

所以修改之后的CMakeLists.txt文件应该是这样的：

cmake_minimum_required(VERSION 3.0)
project(TEST)
file(GLOB SRC_LIST ${CMAKE_CURRENT_SOURCE_DIR}/*.cpp)

include_directories(${PROJECT_SOURCE_DIR}/include)

link_directories(${PROJECT_SOURCE_DIR}/lib)

add_executable(app ${SRC_LIST})

target_link_libraries(app pthread calc)

通过link_directories指定了动态库的路径之后，在执行生成的可执行程序的时候，就不会出现找不到动态库的问题了。

温馨提示：使用 target_link_libraries 命令就可以链接动态库，也可以链接静态库文件。

2.7 日志

在CMake中可以用用户显示一条消息，该命令的名字为message：

message([STATUS|WARNING|AUTHOR_WARNING|FATAL_ERROR|SEND_ERROR] "message to display" ...)

(无) ：重要消息
STATUS ：非重要消息
WARNING：CMake 警告, 会继续执行
AUTHOR_WARNING：CMake 警告 (dev), 会继续执行
SEND_ERROR：CMake 错误, 继续执行，但是会跳过生成的步骤
FATAL_ERROR：CMake 错误, 终止所有处理过程

CMake的命令行工具会在stdout上显示STATUS消息，在stderr上显示其他所有消息。CMake的GUI会在它的log区域显示所有消息。

CMake警告和错误消息的文本显示使用的是一种简单的标记语言。文本没有缩进，超过长度的行会回卷，段落之间以新行做为分隔符。

message(STATUS "source path: ${PROJECT_SOURCE_DIR}")

message(WARNING "source path: ${PROJECT_SOURCE_DIR}")

message(FATAL_ERROR "source path: ${PROJECT_SOURCE_DIR}")

2.8 变量操作

2.8.1 追加

有时候项目中的源文件并不一定都在同一个目录中，但是这些源文件最终却需要一起进行编译来生成最终的可执行文件或者库文件。如果我们通过file命令对各个目录下的源文件进行搜索，最后还需要做一个字符串拼接的操作，关于字符串拼接可以使用set命令也可以使用list命令。

使用set拼接

如果使用set进行字符串拼接，对应的命令格式如下：

set(变量名1 ${变量名1} ${变量名2} ...)

关于上面的命令其实就是将从第二个参数开始往后所有的字符串进行拼接，最后将结果存储到第一个参数中，如果第一个参数中原来有数据会对原数据就行覆盖。

cmake_minimum_required(VERSION 3.0)
project(TEST)
set(TEMP "hello,world")
file(GLOB SRC_1 ${PROJECT_SOURCE_DIR}/src1/*.cpp)
file(GLOB SRC_2 ${PROJECT_SOURCE_DIR}/src2/*.cpp)

set(SRC_1 ${SRC_1} ${SRC_2} ${TEMP})
message(STATUS "message: ${SRC_1}")

使用list拼接

如果使用list进行字符串拼接，对应的命令格式如下：

list(APPEND <list> [<element> ...])

list命令的功能比set要强大，字符串拼接只是它的其中一个功能，所以需要在它第一个参数的位置指定出我们要做的操作，APPEND表示进行数据追加，后边的参数和set就一样了。

cmake_minimum_required(VERSION 3.0)
project(TEST)
set(TEMP "hello,world")
file(GLOB SRC_1 ${PROJECT_SOURCE_DIR}/src1/*.cpp)
file(GLOB SRC_2 ${PROJECT_SOURCE_DIR}/src2/*.cpp)

list(APPEND SRC_1 ${SRC_1} ${SRC_2} ${TEMP})
message(STATUS "message: ${SRC_1}")

在CMake中，使用set命令可以创建一个list。一个在list内部是一个由分号;分割的一组字符串。例如，set(var a b c d e)命令将会创建一个list:a;b;c;d;e，但是最终打印变量值的时候得到的是abcde。

set(tmp1 a;b;c;d;e)
set(tmp2 a b c d e)
message(${tmp1})
message(${tmp2})

输出的结果:

abcde
abcde

2.9 宏定义

在进行程序测试的时候，我们可以在代码中添加一些宏定义，通过这些宏来控制这些代码是否生效，如下所示：

#include <stdio.h>
#define NUMBER  3

int main()
{
    int a = 10;
#ifdef DEBUG
    printf("我是一个程序猿, 我不会爬树...\n");
#endif
    for(int i=0; i<NUMBER; ++i)
    {
        printf("hello, GCC!!!\n");
    }
    return 0;
}

在程序的第七行对DEBUG宏进行了判断，如果该宏被定义了，那么第八行就会进行日志输出，如果没有定义这个宏，第八行就相当于被注释掉了，因此最终无法看到日志输入出（上述代码中并没有定义这个宏）。

为了让测试更灵活，我们可以不在代码中定义这个宏，而是在测试的时候去把它定义出来，其中一种方式就是在gcc/g++命令中去指定，如下：

$ gcc test.c -DDEBUG -o app

在gcc/g++命令中通过参数 -D指定出要定义的宏的名字，这样就相当于在代码中定义了一个宏，其名字为DEBUG。

在CMake中我们也可以做类似的事情，对应的命令叫做add_definitions:

add_definitions(-D宏名称)

针对于上面的源文件编写一个CMakeLists.txt，内容如下：

cmake_minimum_required(VERSION 3.0)
project(TEST)

add_definitions(-DDEBUG)
add_executable(app ./test.c)

通过这种方式，上述代码中的第八行日志就能够被输出出来了。

3. 预定义宏

下面的列表中为大家整理了一些CMake中常用的宏：

宏	功能
PROJECT_SOURCE_DIR	使用cmake命令后紧跟的目录，一般是工程的根目录
PROJECT_BINARY_DIR	执行cmake命令的目录
CMAKE_CURRENT_SOURCE_DIR	当前处理的CMakeLists.txt所在的路径
CMAKE_CURRENT_BINARY_DIR	target 编译目录
EXECUTABLE_OUTPUT_PATH	重新定义目标二进制可执行文件的存放位置
LIBRARY_OUTPUT_PATH	重新定义目标链接库文件的存放位置
PROJECT_NAME	返回通过PROJECT指令定义的项目名称
CMAKE_BINARY_DIR	项目实际构建路径，假设在`build`目录进行的构建，那么得到的就是这个目录的路径

CMake 保姆级教程（下）

如果项目很大，或者项目中有很多的源码目录，在通过CMake管理项目的时候如果只使用一个CMakeLists.txt，那么这个文件相对会比较复杂，有一种化繁为简的方式就是给每个源码目录都添加一个CMakeLists.txt文件（头文件目录不需要），这样每个文件都不会太复杂，而且更灵活，更容易维护。

先来看一下下面的这个的目录结构：

$ tree
.
├── build
├── calc
│   ├── add.cpp
│   ├── CMakeLists.txt
│   ├── div.cpp
│   ├── mult.cpp
│   └── sub.cpp
├── CMakeLists.txt
├── include
│   ├── calc.h
│   └── sort.h
├── sort
│   ├── CMakeLists.txt
│   ├── insert.cpp
│   └── select.cpp
├── test1
│   ├── calc.cpp
│   └── CMakeLists.txt
└── test2
    ├── CMakeLists.txt
    └── sort.cpp

6 directories, 15 files

include 目录：头文件目录
calc 目录：目录中的四个源文件对应的加、减、乘、除算法
- 对应的头文件是include中的calc.h
sort 目录 ：目录中的两个源文件对应的是插入排序和选择排序算法
- 对应的头文件是include中的sort.h
test1 目录：测试目录，对加、减、乘、除算法进行测试
test2 目录：测试目录，对排序算法进行测试

可以看到各个源文件目录所需要的CMakeLists.txt文件现在已经添加完毕了。接下来庖丁解牛，我们依次分析一下各个文件中需要添加的内容。

1.1 准备工作

1.1.1 节点关系

众所周知，Linux的目录是树状结构，所以嵌套的 CMake 也是一个树状结构，最顶层的 CMakeLists.txt 是根节点，其次都是子节点。因此，我们需要了解一些关于 CMakeLists.txt 文件变量作用域的一些信息：

根节点CMakeLists.txt中的变量全局有效
父节点CMakeLists.txt中的变量可以在子节点中使用
子节点CMakeLists.txt中的变量只能在当前节点中使用

1.1.2 添加子目录

接下来我们还需要知道在 CMake 中父子节点之间的关系是如何建立的，这里需要用到一个 CMake 命令：

add_subdirectory(source_dir [binary_dir] [EXCLUDE_FROM_ALL])

source_dir：指定了CMakeLists.txt源文件和代码文件的位置，其实就是指定子目录
binary_dir：指定了输出文件的路径，一般不需要指定，忽略即可。
EXCLUDE_FROM_ALL：在子路径下的目标默认不会被包含到父路径的ALL目标里，并且也会被排除在IDE工程文件之外。用户必须显式构建在子路径下的目标。

通过这种方式CMakeLists.txt文件之间的父子关系就被构建出来了。

1.2 解决问题

在上面的目录中我们要做如下事情：

通过 test1 目录中的测试文件进行计算器相关的测试
通过 test2 目录中的测试文件进行排序相关的测试

现在相当于是要进行模块化测试，对于calc和sort目录中的源文件来说，可以将它们先编译成库文件（可以是静态库也可以是动态库）然后在提供给测试文件使用即可。库文件的本质其实还是代码，只不过是从文本格式变成了二进制格式。

1.2.1 根目录

根目录中的 CMakeLists.txt文件内容如下：

cmake_minimum_required(VERSION 3.0)
project(test)


set(LIB_PATH ${CMAKE_CURRENT_SOURCE_DIR}/lib)

set(EXEC_PATH ${CMAKE_CURRENT_SOURCE_DIR}/bin)

set(HEAD_PATH ${CMAKE_CURRENT_SOURCE_DIR}/include)

set(CALC_LIB calc)
set(SORT_LIB sort)

set(APP_NAME_1 test1)
set(APP_NAME_2 test2)

add_subdirectory(calc)
add_subdirectory(sort)
add_subdirectory(test1)
add_subdirectory(test2)

在根节点对应的文件中主要做了两件事情：定义全局变量和添加子目录。

定义的全局变量主要是给子节点使用，目的是为了提高子节点中的CMakeLists.txt文件的可读性和可维护性，避免冗余并降低出差的概率。
一共添加了四个子目录，每个子目录中都有一个CMakeLists.txt文件，这样它们的父子关系就被确定下来了。

2. 流程控制

在 CMake 的 CMakeLists.txt 中也可以进行流程控制，也就是说可以像写 shell 脚本那样进行条件判断和循环。

2.1 条件判断

关于条件判断其语法格式如下：

if(<condition>)
  <commands>
elseif(<condition>)
  <commands>
else()
  <commands>
endif()

在进行条件判断的时候，如果有多个条件，那么可以写多个elseif，最后一个条件可以使用else，但是开始和结束是必须要成对出现的，分别为：if和endif。

2.1.1 基本表达式

if(<expression>)

如果是基本表达式，expression 有以下三种情况：常量、变量、字符串。

如果是1, ON, YES, TRUE, Y, 非零值，非空字符串时，条件判断返回True
如果是 0, OFF, NO, FALSE, N, IGNORE, NOTFOUND，空字符串时，条件判断返回False

2.1.2 逻辑判断

NOT
```
if(NOT <condition>)
```
其实这就是一个取反操作，如果条件condition为True将返回False，如果条件condition为False将返回True。
AND
```
if(<cond1> AND <cond2>)
```
如果cond1和cond2同时为True，返回True否则返回False。
OR
```
if(<cond1> OR <cond2>)
```
如果cond1和cond2两个条件中至少有一个为True，返回True，如果两个条件都为False则返回False。

2.2 循环

在 CMake 中循环有两种方式，分别是：foreach和while。

2.2.1 foreach

使用 foreach 进行循环，语法格式如下：

foreach(<loop_var> <items>)
    <commands>
endforeach()

通过foreach我们就可以对items中的数据进行遍历，然后通过loop_var将遍历到的当前的值取出，在取值的时候有以下几种用法：

方法1

foreach(<loop_var> RANGE <stop>)

RANGE：关键字，表示要遍历范围
stop：这是一个正整数，表示范围的结束值，在遍历的时候从 0 开始，最大值为 stop。
loop_var：存储每次循环取出的值

举例说明：

cmake_minimum_required(VERSION 3.2)
project(test)

foreach(item RANGE 10)
    message(STATUS "当前遍历的值为: ${item}" )
endforeach()

输出的日志信息是这样的：

$ cmake ..
-- 当前遍历的值为: 0
-- 当前遍历的值为: 1
-- 当前遍历的值为: 2
-- 当前遍历的值为: 3
-- 当前遍历的值为: 4
-- 当前遍历的值为: 5
-- 当前遍历的值为: 6
-- 当前遍历的值为: 7
-- 当前遍历的值为: 8
-- 当前遍历的值为: 9
-- 当前遍历的值为: 10
-- Configuring done
-- Generating done
-- Build files have been written to: /home/robin/abc/a/build

再次强调：在对一个整数区间进行遍历的时候，得到的范围是这样的【0，stop】，右侧是闭区间包含 stop 这个值。

方法2

foreach(<loop_var> RANGE <start> <stop> [<step>])

这是上面方法1的加强版，我们在遍历一个整数区间的时候，除了可以指定起始范围，还可以指定步长。

RANGE：关键字，表示要遍历范围
start：这是一个正整数，表示范围的起始值，也就是说最小值为 start
stop：这是一个正整数，表示范围的结束值，也就是说最大值为 stop
step：控制每次遍历的时候以怎样的步长增长，默认为1，可以不设置
loop_var：存储每次循环取出的值

举例说明：

cmake_minimum_required(VERSION 3.2)
project(test)

foreach(item RANGE 10 30 2)
    message(STATUS "当前遍历的值为: ${item}" )
endforeach()

输出的结果如下:

$ cmake ..
-- 当前遍历的值为: 10
-- 当前遍历的值为: 12
-- 当前遍历的值为: 14
-- 当前遍历的值为: 16
-- 当前遍历的值为: 18
-- 当前遍历的值为: 20
-- 当前遍历的值为: 22
-- 当前遍历的值为: 24
-- 当前遍历的值为: 26
-- 当前遍历的值为: 28
-- 当前遍历的值为: 30
-- Configuring done
-- Generating done
-- Build files have been written to: /home/robin/abc/a/build

再次强调：在使用上面的方式对一个整数区间进行遍历的时候，得到的范围是这样的【start，stop】，左右两侧都是闭区间，包含 start 和 stop 这两个值，步长 step 默认为1，可以不设置。

方法3

foreach(<loop_var> IN [LISTS [<lists>]] [ITEMS [<items>]])

这是foreach的另一个变体，通过这种方式我们可以对更加复杂的数据进行遍历，前两种方式只适用于对某个正整数范围内的遍历。

IN：关键字，表示在 xxx 里边
LISTS：关键字，对应的是列表list，通过set、list可以获得
ITEMS：关键字，对应的也是列表
loop_var：存储每次循环取出的值

cmake_minimum_required(VERSION 3.2)
project(test)

set(WORD a b c d)
set(NAME ace sabo luffy)

foreach(item IN LISTS WORD NAME)
    message(STATUS "当前遍历的值为: ${item}" )
endforeach()

在上面的例子中，创建了两个 list 列表，在遍历的时候对它们两个都进行了遍历（可以根据实际需求选择同时遍历多个或者只遍历一个）。输出的日志信息如下：

$ cd build/
$ cmake ..
-- 当前遍历的值为: a
-- 当前遍历的值为: b
-- 当前遍历的值为: c
-- 当前遍历的值为: d
-- 当前遍历的值为: ace
-- 当前遍历的值为: sabo
-- 当前遍历的值为: luffy
-- Configuring done
-- Generating done
-- Build files have been written to: /home/robin/abc/a/build

一共输出了7个字符串，说明遍历是没有问题的。接下来看另外一种方式：

cmake_minimum_required(VERSION 3.2)
project(test)

set(WORD a b c "d e f")
set(NAME ace sabo luffy)
foreach(item IN ITEMS ${WORD} ${NAME})
    message(STATUS "当前遍历的值为: ${item}" )
endforeach()

在上面的例子中，遍历过程中将关键字LISTS改成了ITEMS，后边跟的还是一个或者多个列表，只不过此时需要通过${}将列表中的值取出。其输出的信息和上一个例子是一样的：

$ cd build/
$ cmake ..
-- 当前遍历的值为: a
-- 当前遍历的值为: b
-- 当前遍历的值为: c
-- 当前遍历的值为: d e f
-- 当前遍历的值为: ace
-- 当前遍历的值为: sabo
-- 当前遍历的值为: luffy
-- Configuring done
-- Generating done
-- Build files have been written to: /home/robin/abc/a/build

小细节：在通过 set 组织列表的时候，如果某个字符串中有空格，可以通过双引号将其包裹起来，具体的操作方法可以参考上面的例子。

方法4

注意事项：这种循环方式要求CMake的版本大于等于 3.17。

foreach(<loop_var>... IN ZIP_LISTS <lists>)

通过这种方式，遍历的还是一个或多个列表，可以理解为是方式3的加强版。因为通过上面的方式遍历多个列表，但是又想把指定列表中的元素取出来使用是做不到的，在这个加强版中就可以轻松实现。

loop_var：存储每次循环取出的值，可以根据要遍历的列表的数量指定多个变量，用于存储对应的列表当前取出的那个值。
- 如果指定了多个变量名，它们的数量应该和列表的数量相等
- 如果只给出了一个 loop_var，那么它将一系列的 loop_var_N 变量来存储对应列表中的当前项，也就是说 loop_var_0 对应第一个列表，loop_var_1 对应第二个列表，以此类推......
- 如果遍历的多个列表中一个列表较短，当它遍历完成之后将不会再参与后续的遍历（因为其它列表还没有遍历完）。
IN：关键字，表示在 xxx 里边
ZIP_LISTS：关键字，对应的是列表list，通过set 、list可以获得

cmake_minimum_required(VERSION 3.17)
project(test)

list(APPEND WORD hello world "hello world")
list(APPEND NAME ace sabo luffy zoro sanji)

foreach(item1 item2 IN ZIP_LISTS WORD NAME)
    message(STATUS "当前遍历的值为: item1 = ${item1}, item2=${item2}" )
endforeach()

message("=============================")

foreach(item  IN ZIP_LISTS WORD NAME)
    message(STATUS "当前遍历的值为: item1 = ${item_0}, item2=${item_1}" )
endforeach()

在这个例子中关于列表数据的添加是通过list来实现的。在遍历列表的时候一共使用了两种方式，一种提供了多个变量来存储当前列表中的值，另一种只有一个变量，但是实际取值的时候需要通过变量名_0、变量名_1、变量名_N 的方式来操作，注意事项：第一个列表对应的编号是0，第一个列表对应的编号是0，第一个列表对应的编号是0。

上面的例子输出的结果如下：

$ cd build/
$ cmake ..
-- 当前遍历的值为: item1 = hello, item2=ace
-- 当前遍历的值为: item1 = world, item2=sabo
-- 当前遍历的值为: item1 = hello world, item2=luffy
-- 当前遍历的值为: item1 = , item2=zoro
-- 当前遍历的值为: item1 = , item2=sanji
=============================
-- 当前遍历的值为: item1 = hello, item2=ace
-- 当前遍历的值为: item1 = world, item2=sabo
-- 当前遍历的值为: item1 = hello world, item2=luffy
-- 当前遍历的值为: item1 = , item2=zoro
-- 当前遍历的值为: item1 = , item2=sanji
-- Configuring done (0.0s)
-- Generating done (0.0s)
-- Build files have been written to: /home/robin/abc/a/build

Reference

【1】 https://subingwen.cn/cmake/CMake-advanced/