系统：MacOS

Python版本：3.12

测试时间：2026-06-19

不知道大家有没有做过"从数据里猜测其符合什么样的y=f(x)数学公式"这样的事情？在很多年前没有AI的时代，这个领域基本是欧美软件的天下，后来出现了一个石破天惊的国产软件1stOpt( http://www.7d-soft.com/ )打破了它们的垄断，在当年算是国产软件在这个领域取得的重大成就。 巧了，这两天我刚好看到科技媒体报道了一个新的国产开源软件 FunctionEvolve ，正是和解决此类问题有关，于是我去了解了一下，并且拿它做了一些简单的测试，写成此文。
本站的关联文章链接：最优化/Optimization文章合集

在正文开始之前我想先闲聊一下，文中测试使用的大模型是DeepSeek V4 Flash，测试过程中总共用了30多万token，花费0.19元，由于任务的性质缓存命中率很低，但DS定价太便宜所以几乎没花钱。

下面开始正文。

FunctionEvolve （ https://github.com/Phoinikas03/FunctionEvolve ）是一个符号回归（Symbolic Regression）搜索框架，核心目标是从数值数据中自动发现数学公式。它采用 LLM + 传统数值优化 的混合架构：LLM 负责分析领域知识、生成种子公式、选择父本和定向变异建议；传统优化器（DE / CMA-ES / L-BFGS-B / TRF）负责拟合公式中的参数。
文章来源：https://www.codelast.com/

同类软件一览

符号回归和自动公式发现领域已有不少成熟工具，按原理大致可分为两类：

类别	代表软件	国别	核心技术
传统全局优化	1stOpt	国产	UGO（通用全局优化），无需初值
	MATLAB Curve Fitting		Trust-Region / Levenberg-Marquardt
	OriginPro		Levenberg-Marquardt / 全局优化
	DataFit		多算法自动搜索
遗传编程 (GP)	Eureqa		遗传编程符号回归（最早商业化的 GP 工具）
	PySR	开源	遗传编程（Python 库）
	GPTIPS		多基因遗传编程（MATLAB）
	gplearn	开源	遗传编程（Python 库）
LLM + 优化	FunctionEvolve	开源	LLM 指导搜索方向 + 数值优化器拟合参数

重点说明：1stOpt（七维高科）

我很多年以前用过几次 1stOpt，当时对它留下了深刻印象（不知道现在是否还在维护），所以这里单独介绍一下。

1stOpt 是国内 7D-Soft 开发的数值优化分析软件，在工程和科研领域有大量用户。它的核心特点是：

• 无需人工初值 — 传统工具（如 MATLAB）做曲线拟合时，参数初值给不对就会发散或收敛到局部最优。1stOpt 内置 UGO（通用全局优化） 算法族，号称"万用公式，任意初值"。
• 公式模板驱动 — 用户提供公式骨架（如 y = a*x^b + c*e^(d*x)），1stOpt 负责搜索最优参数。和 FunctionEvolve 相比，1stOpt 的公式结构需要人先指定，FunctionEvolve 则连结构也可以自动发现。
• 适用场景 — 曲线/曲面拟合、非线性回归、参数估计、微分方程求解、工程反演。
• 局限 — 商业软件、闭源、Windows 独占。公式结构依赖用户经验，无法自动探索未知结构。

在 FunctionEvolve 中，大模型起什么作用

LLM 起的是"搜索方向指导"作用，数学计算由传统优化器完成。

FunctionEvolve 是 LLM + 传统数值优化 的混合架构，LLM 不做数学计算。

完整工作流

阶段	组件	是否用 LLM	作用
① 领域分析	Generator	LLM	分析问题属于什么领域（物理/化学/生物...），给出该领域常见公式模板
② 种子生成	Generator	LLM	基于领域知识，生成 20 个初始候选公式（带参数占位符 c0, c1...）
③ 参数拟合	StructureOptimizer	纯数值	VARPRO + DE + CMA-ES + L-BFGS-B，拟合 c0, c1... 的最优值
④ 评估	Evaluator	纯数值	计算 NMSE（归一化均方误差）
⑤ 选父本	Selector	LLM	看当前进化树所有公式的 NMSE 和结构，决定下一轮"从哪些公式出发"
⑥ 结构变异	ASTMutator	规则引擎	程序化地删子树、加项、拆函数包装，生成候选变体
⑦ 结构建议	LLMMutator	LLM	"试试加个 sin 项"、"试试把 x² 换成 exp(x)"
⑧ 回到 ③	循环	—	拟合 → 评估 → 选父本 → 变异 → 再拟合...

优化算法详情

所有参数拟合（阶段③）由 StructureOptimizer 执行，它是一个多策略流水线。

第三方库提供的基础算法（4 个）

项目自身实现的策略（3 个）

StructureOptimizer 执行流水线

输入: 公式骨架 + 数据
  │
  ├─ ① Pow 预搜索 (Compound-Pow pre-search)
  │   枚举候选指数，固定后用 VARPRO 拟合其余参数
  │
  ├─ ② VARPRO 分解 (主路径)
  │   线性参数 → np.linalg.lstsq OLS 求解
  │   非线性参数 → DE / CMA / TRF 并行搜索
  │
  ├─ ③ 并行兜底 (DE / CMA / TRF 同时跑, 取最优)
  │
  ├─ ④ L-BFGS-B 局部精修
  │
  ├─ ⑤ Pow 指数对齐 & 重拟合
  │
  └─ 输出: 最优参数 + NMSE

所有路径均有超时保护和多次重启机制。
文章来源：https://www.codelast.com/

关键源码位置

一句话总结

LLM 是"策略师"——告诉你该往哪个方向找公式；数学优化器是"计算器"——实际算出参数值。

LLM 不碰任何数值计算。所有参数拟合由 StructureOptimizer 以 VARPRO → DE/CMA/TRF（并行全局搜索）→ L-BFGS-B（局部精修）→ Pow 指数对齐 的多层流水线完成。

完整测试流程

以下是从零开始创建测试数据、搭建环境、运行测试、清理环境的完整步骤记录。 

测试目标

验证 FunctionEvolve 能否从数值数据中自动发现复杂公式：

$y = \frac{\sin(x_1 x_2)}{\cos(x_3) + 1.5} + e^{-x_2} \cdot \ln(|x_4| + 1) + \frac{x_1 x_3}{1 + x_5^2}$

步骤一览

Step 1: 生成测试数据集
Step 2: 创建临时 Python 环境并安装依赖
Step 3: 编写测试脚本
Step 4: 运行测试
Step 5: 查看结果
Step 6: 删除临时环境

Step 1：生成测试数据集

cd /path/to/FunctionEvolve
python3 datasets/z/generate_complex_dataset.py --noise-std 0.02

生成程序完整源码

保存为 datasets/z/generate_complex_dataset.py：

#!/usr/bin/env python3
"""
生成一个复杂公式的符号回归数据集，用于验证 FunctionEvolve 的效果。

公式（5 个输入变量，混合三角函数、指数、对数、有理分式）:

    sin(x1 * x2)                              x1 * x3
y = ──────────── + exp(-x2) * ln(|x4| + 1) + ─────────
    cos(x3) + 1.5                             1 + x5²


输出:
  datasets/z/
    dataset.npz        — NumPy 压缩格式（直接用 from_arrays 加载）
    dataset.csv        — CSV 文本格式（肉眼查看用）
    ground_truth.txt   — 真实公式说明
    preview.txt        — 数据统计摘要
"""

from __future__ import annotations
import argparse
from pathlib import Path
import numpy as np

GROUND_TRUTH_EXPRESSION = (
    "sin(x1 * x2) / (cos(x3) + 1.5) + exp(-x2) * log(abs(x4) + 1) + x1 * x3 / (1 + x5**2)"
)

GROUND_TRUTH_SYMBOLS = ["x1", "x2", "x3", "x4", "x5"]
RNG = np.random.RandomState(42)


def _safe_log_abs(x):
    return np.log(np.abs(x) + 1.0)


def ground_truth_y(X):
    x1, x2, x3, x4, x5 = X[:, 0], X[:, 1], X[:, 2], X[:, 3], X[:, 4]
    term1 = np.sin(x1 * x2) / (np.cos(x3) + 1.5)
    term2 = np.exp(-x2) * _safe_log_abs(x4)
    term3 = x1 * x3 / (1.0 + x5**2)
    return term1 + term2 + term3


def main():
    parser = argparse.ArgumentParser(description="生成复杂符号回归数据集")
    parser.add_argument("--n-train", type=int, default=2000)
    parser.add_argument("--n-test", type=int, default=500)
    parser.add_argument("--noise-std", type=float, default=0.0)
    parser.add_argument("--output-dir", type=str, default=None)
    args = parser.parse_args()

    out_dir = Path(args.output_dir) if args.output_dir else Path(__file__).resolve().parent
    out_dir.mkdir(parents=True, exist_ok=True)

    # 生成训练集
    X_train = RNG.uniform(low=-3.0, high=3.0, size=(args.n_train, 5))
    y_train = ground_truth_y(X_train)
    if args.noise_std > 0:
        y_train += RNG.normal(0, args.noise_std, size=args.n_train)

    # 生成测试集
    rng_test = np.random.RandomState(2024)
    X_test = rng_test.uniform(low=-3.0, high=3.0, size=(args.n_test, 5))
    y_test = ground_truth_y(X_test)
    if args.noise_std > 0:
        y_test += rng_test.normal(0, args.noise_std, size=args.n_test)

    # 保存 NumPy 格式
    np.savez(out_dir / "dataset.npz",
             X_train=X_train, y_train=y_train,
             X_test=X_test, y_test=y_test,
             expression=GROUND_TRUTH_EXPRESSION)

    # 保存 CSV
    header = ",".join(GROUND_TRUTH_SYMBOLS) + ",y"
    rows = np.column_stack([np.vstack([X_train, X_test]),
                            np.hstack([y_train, y_test])])
    with open(out_dir / "dataset.csv", "w") as f:
        f.write(f"# 真实公式: {GROUND_TRUTH_EXPRESSION}\n")
        f.write(f"# 噪声标准差: {args.noise_std}\n")
        f.write(header + "\n")
        for row in rows:
            f.write(",".join(f"{v:.8f}" for v in row) + "\n")

    print(f"数据集已保存到 {out_dir}")


if __name__ == "__main__":
    main()

生成的数据样例

x1,x2,x3,x4,x5,y
-0.75275929,2.70428584,1.39196365,0.59195091,-2.06388816,-0.73060157
-2.06403288,-2.65149833,2.19705687,0.60669007,1.24843547,4.13384154
-2.87649303,2.81945911,1.99465584,-1.72596534,-1.90905020,-2.05631804
-1.89957294,-1.17454654,0.14853859,-0.40832989,-1.25262516,1.29225609

每行 6 列：x₁ ~ x₅ 为输入，y 为输出。

产出文件：

Step 2：创建临时环境

使用 micromamba 创建独立的 Python 3.12 环境，避免污染已有环境：

# 创建
micromamba create -n py312 python=3.12 -y

# 安装依赖
micromamba run -n py312 pip3 install scipy sympy scikit-learn h5py \
    tiktoken json-repair cmaes threadpoolctl

Step 3：编写测试脚本

保存为 datasets/z/run_test.py：

#!/usr/bin/env python3
"""
在 FunctionEvolve 上运行自定义复杂数据集（datasets/z/dataset.npz）的测试脚本。

用法:
  cd /path/to/FunctionEvolve

  # 退化模式（无 LLM，仅验证程序化变异 + 数值优化）
  python datasets/z/run_test.py --degenerated

  # 完整模式（使用 LLM，需要 llm_config.yaml）
  python datasets/z/run_test.py
"""

import argparse
import os
import sys
from pathlib import Path

import numpy as np

PROJECT_ROOT = Path(__file__).resolve().parents[2]
sys.path.insert(0, str(PROJECT_ROOT))

from src.dataset import SRDataset
from src.evaluator import Evaluator
from src.evolution_tree import EvolutionTree
from src.search import TreeSearch
from src.generator import MockGenerator, create_generator
from src.selector import MockSelector, create_selector
from src.mutator import MockMutator, LLMMutator
from src.llm_client import build_openai_client, LLMUsageLogger


def _load_dataset(data_dir):
    npz_path = data_dir / "dataset.npz"
    data = np.load(npz_path)
    expr = str(data["expression"].item())
    return SRDataset.from_arrays(
        X_train=data["X_train"], y_train=data["y_train"],
        X_test=data["X_test"], y_test=data["y_test"],
        symbols=["x1", "x2", "x3", "x4", "x5"],
        symbol_descs=["v1", "v2", "v3", "v4", "v5"],
        expression=expr, equation_name="complex_z",
    )


def _evaluate_ground_truth(ds, evaluator):
    """对真实公式做参数拟合，给出精度天花板。"""
    import sympy as sp
    sympy_expr = sp.sympify(ds.expression)
    param_names = sorted(
        {str(s) for s in sympy_expr.free_symbols} - set(ds.feature_names))
    result = evaluator.evaluate_skeleton(sympy_expr, param_names)
    print(f"[Ground Truth] Train NMSE = {result.train_nmse:.2e}")
    print(f"[Ground Truth] Test  NMSE = {result.test_nmse:.2e}")


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--degenerated", action="store_true")
    parser.add_argument("--max-steps", type=int, default=30)
    parser.add_argument("--n-seeds", type=int, default=20)
    parser.add_argument("--candidate-num", type=int, default=5)
    parser.add_argument("--timeout", type=float, default=120.0)
    parser.add_argument("--llm-config", type=str, default=None)
    parser.add_argument("--run-tag", type=str, default="z_test")
    args = parser.parse_args()

    data_dir = Path(__file__).resolve().parent
    ds = _load_dataset(data_dir)
    print(f"训练样本: {ds.X_train.shape[0]}, 测试样本: {ds.X_test.shape[0]}")

    evaluator = Evaluator(
        feature_names=ds.feature_names, X_train=ds.X_train,
        y_train=ds.y_train, X_test=ds.X_test, y_test=ds.y_test,
        timeout=args.timeout,
    )
    _evaluate_ground_truth(ds, evaluator)

    # 构造 LLM / Mock Agent
    llm_config = None
    if not args.degenerated:
        cfg_path = args.llm_config or str(PROJECT_ROOT / "llm_config.yaml")
        if os.path.exists(cfg_path):
            import yaml
            with open(cfg_path) as f:
                llm_config = yaml.safe_load(f) or {}

    def _resolve(comp, field, fallback=None):
        return llm_config.get(comp, {}).get(field, fallback) if llm_config else fallback

    if args.degenerated:
        generator = MockGenerator(variables=ds.feature_names)
        selector = MockSelector(variables=ds.feature_names)
        llm_mutator = MockMutator()
    else:
        gen = _resolve("generator", "model"); gen_url = _resolve("generator", "base_url")
        gen_key = _resolve("generator", "api_key"); gen_mode = _resolve("generator", "mode", "openai")
        gen_temp = _resolve("generator", "temperature", 0.8)
        gen_tok = _resolve("generator", "max_tokens", 128000)
        logger = LLMUsageLogger(str(Path("logs") / "z_custom" / "llm_usage.csv"))
        generator = create_generator(gen, gen_url, gen_key, gen_temp, gen_tok,
                                     usage_logger=logger, llm_mode=gen_mode)

        sm = _resolve("selector", "model", gen); su = _resolve("selector", "base_url", gen_url)
        sk = _resolve("selector", "api_key", gen_key); sd = _resolve("selector", "mode", gen_mode)
        st = _resolve("selector", "temperature", 0.3)
        selector = create_selector(sm, su, sk, st, usage_logger=logger, llm_mode=sd)

        mm = _resolve("mutator", "model", gen); mu = _resolve("mutator", "base_url", gen_url)
        mk = _resolve("mutator", "api_key", gen_key); md = _resolve("mutator", "mode", gen_mode)
        mt = _resolve("mutator", "temperature", 0.7)
        m_tok = _resolve("mutator", "max_tokens", 128000)
        client = build_openai_client(mm, mu, mode=md, api_key=mk)
        llm_mutator = LLMMutator(client, mm, mt, m_tok, usage_logger=logger)

    tree = EvolutionTree()
    searcher = TreeSearch(
        dataset=ds, evaluator=evaluator, tree=tree,
        selector=selector, generator=generator, llm_mutator=llm_mutator,
        max_steps=args.max_steps, n_seeds=args.n_seeds,
        candidate_num=args.candidate_num, timeout=args.timeout, verbose=True,
    )
    searcher.initialize_seeds()
    searcher.run()

    # 输出最佳结果
    evaluated = [n for n in tree.all_nodes if n.is_evaluated and n.train_nmse < float("inf")]
    evaluated.sort(key=lambda n: n.train_nmse)
    if evaluated:
        best = evaluated[0]
        print(f"\n最佳公式: {best.skeleton_str}")
        print(f"训练集 NMSE: {best.train_nmse:.4e}")
        print(f"测试集 NMSE: {best.test_nmse:.4e}")


if __name__ == "__main__":
    main()

Step 4：运行测试

共运行三个实验：

① 退化模式（1 步）：

cd /path/to/FunctionEvolve
python3 datasets/z/run_test.py --degenerated --max-steps 1 --n-seeds 3 --candidate-num 2 --timeout 120

② LLM 模式（1 步）：

cd /path/to/FunctionEvolve
python3 datasets/z/run_test.py --max-steps 1 --n-seeds 3 --candidate-num 2 --timeout 120

③ LLM 模式（3 步）：

cd /path/to/FunctionEvolve
python3 datasets/z/run_test.py --max-steps 3 --n-seeds 3 --candidate-num 2 --timeout 120

为加快运行速度，上述实验使用了 200 训练样本 + 100 测试样本的子集（完整数据集为 2000 + 500）。

Step 5：测试输出及分析

[Ground Truth] 训练集 NMSE = 1.77e-05
[Ground Truth] 测试集 NMSE = 2.14e-05

真实公式本身不需要拟合任何参数，NMSE ≈ 1.8e-5 来自 0.02 标准差的高斯噪声，是本次测试的精度天花板。
文章来源：https://www.codelast.com/

模式 A：退化模式结果（200 样本）

初始种子（退化模式仅基于 x1 生成简易多项式/指数公式）：

最优变异后（1 步，2 父本，111 个候选）：

退化模式瓶颈：种子只使用 x1，NMSE approx 1.0；一轮变异后最优 NMSE 0.270（解释 ~73% 方差）。但缺乏 LLM 指引方向，变异盲目枚举（111 个候选中仅少数引入 x2，无法发现 sin 等函数）。

模式 B：完整模式结果（使用 DeepSeek，200 样本）

1. LLM Generator 领域分析

LLM 成功分析出数据集属于"通用符号回归 / 数学建模"领域，输出了 20+ 个经典公式模式供种子生成参考。

2. LLM 种子生成

LLM 的第三个种子 c0exp(c1x2) + c2sin(c3x3 + c4) 已经包含了 exp + sin，NMSE 仅 ~0.35，远超退化种子的 ~0.998。

3. LLM Mutator 变异建议

LLM 为选中的父本生成了 20 条定向变异建议（退化模式中 ASTMutator 靠穷举生成了约 111 条），例如："尝试多项式展开"、"添加指数衰减项 exp"、"尝试分式结构"、"添加正弦/余弦项"。

4. 各步最优公式

LLM 1 步后：

LLM 3 步后：

两种模式找到的最优函数：

NMSE 对比（越低越好）：

LLM 1 步内就发现了退化模式无法找到的 sin()。3 步后 NMSE 降到 0.081（解释 ~92% 方差），但 x₁×x₂ 的 sin 交互和 x₅ 尚未被完整识别。预计 LLM 模式 5~10 步可收敛到 NMSE < 1e-3。

当前进度与收敛预估

当前实验进度（基于 200 训练样本 + 100 测试样本）：

LLM 3 步后 NMSE 0.081（解释 ~92% 方差），已成功发现 sin() 函数并引入了 x₁~x₄ 四个变量。但真实公式中 x₁×x₂ 的 sin 交互、x₁×x₃ 的分式交互以及 x₅ 的分式尚未被完整识别。预计：

• LLM 模式：5~10 步可收敛到 NMSE < 1e-3
• 退化模式：相同步数下 NMSE 下降仅 ~18%/步，效率远低于 LLM

这正是 FunctionEvolve 采用 LLM + 数值优化混合架构的原因——LLM 提供方向，数值优化负责精确拟合。
文章来源：https://www.codelast.com/

Step 6：清理临时环境

# 测试完成后删除临时环境
micromamba remove -n py312 --all -y

总结

结论：FunctionEvolve 的搜索管道可以正常运行。LLM 模式显著优于退化模式——1 步即可发现退化模式无法找到的 sin() 函数，3 步后 NMSE 降至 0.081。其实上面的测试还没有找到最终的正确公式，由于我电脑性能不强，仅仅运行上面的测试就已经花了很长时间+风扇狂转，因此测试只能止步于此。但可以看到，FunctionEvolve相较于传统优化方法是有较大优势的。

文章来源：https://www.codelast.com/
➤➤ 版权声明 ➤➤ 
转载需注明出处：codelast.com 
感谢关注我的微信公众号（微信扫一扫）：

以及我的微信视频号：

hadoop fs -cp /path/to/your/hive/table/hdfs/dir/date=2026-03-20 /path/to/your/hive/table/hdfs/dir/date=2026-03-21

（2）光复制目录没用，数据仍然是查询不到的，需要用在Hive命令行交互模式下，执行以下命令让复制出来的数据"生效"

msck repair table 表名;

该命令用于修复表的元数据。
直接在 HDFS 上创建了分区目录，但未通过 ALTER TABLE ADD PARTITION 命令注册到 Hive 元数据中，运行msck命令后，这些分区会被自动发现并添加到元数据。

这个效果是怎么实现的呢？按如下步骤操作——
以MacOS为例，安装：

brew install git-delta

全局配置到git，修改 ~/.gitconfig 文件，添加如下内容：

[core]

    pager = delta

[interactive]

    diffFilter = delta --color-only

[delta]

    syntax-theme = Monokai Extended

    line-numbers = true

    side-by-side = true

我们首先要知道几个背景知识：
➤ whisper.cpp 是一个开源的 C/C++ 实现，用于运行 OpenAI 的 Whisper 模型。Whisper 是一种先进的自动语音识别（Automatic Speech Recognition, ASR）神经网络模型，能够将音频转换为文本。它支持多种语言，识别效果精准，并且可以完全离线运行，无需互联网连接。这个项目特别适合嵌入到各种应用程序中，因为它是轻量级的实现，可以在 CPU 上高效运行。
➤ whisper.cpp-cli 是对 whisper.cpp 命令行工具的 Python 封装。
➤ OpenAI 的 Whisper 模型是一个先进的自动语音识别系统。它是基于 Transformer 架构的神经网络模型，主要用于将音频转换为文本。Whisper 由 OpenAI 开源开发，使用了大规模的多语言数据集进行训练（包括 68 万小时的音频数据，支持 98 种语言），因此具有出色的准确性和鲁棒性，能够处理多种口音、背景噪音和技术术语。
文章来源：https://www.codelast.com/
因此，我们需要安装的是 whisper.cpp-cli，并且要下载好 Whisper 模型文件，这样就能使用 whisper.cpp-cli 来调用Whisper模型文件进行语音识别了。
为了不影响系统里安装的软件，我们通常都会用micromamba、uv之类的Python包管理器创建一个新的env（环境），然后在里面再安装其他的Python包。这里我们用uv，你也可以用其他的包管理器来创建env。

mkdir whisper
cd whisper
uv venv . --python 3.8  # 创建一个新环境
source bin/activate  # 激活环境
uv pip install pip  # 安装pip
pip install whisper.cpp-cli  # 安装whisper.cpp-cli

这样我们就安装好了相关软件。
文章来源：https://www.codelast.com/
把 mp3 转成 16 kHz 的 wav 文件：

ffmpeg -y -i /home/codelast/st.mp3 -ar 16000 /home/codelast/st.wav

注意，16 kHz 是Whisper要求的。

然后我们就可以开始做语音识别了：

 whisper-cpp -m ../whisper.cpp/download/x-ggml-model.zh.bin -f /home/codelast/st.wav -l zh --output-txt

这个命令的参数：
-m：指定使用 x-ggml-model.zh.bin 这个模型来做语音识别（模型文件要提前从 Hugging Face 上下载好）
-f：指定输入文件，对 st.wav 这个音频文件进行语音识别
-l：指定输出语言为中文
--output-txt：直接输出txt文本。
文章来源：https://www.codelast.com/
输出内容示例如下：

whisper_init_from_file_with_params_no_state: loading model from '../whisper.cpp/download/x-ggml-model.zh.bin'

whisper_model_load: loading model

whisper_model_load: n_vocab       = 51865

whisper_model_load: n_audio_ctx   = 1500

whisper_model_load: n_audio_state = 768

whisper_model_load: n_audio_head  = 12

whisper_model_load: n_audio_layer = 12

whisper_model_load: n_text_ctx    = 448

whisper_model_load: n_text_state  = 768

whisper_model_load: n_text_head   = 12

whisper_model_load: n_text_layer  = 12

whisper_model_load: n_mels        = 80

whisper_model_load: ftype         = 1

whisper_model_load: qntvr         = 0

whisper_model_load: type          = 3 (small)

whisper_model_load: adding 1608 extra tokens

whisper_model_load: n_langs       = 99

whisper_model_load:      CPU total size =   487.01 MB

whisper_model_load: model size    =  487.01 MB

whisper_init_state: kv self size  =   49.55 MB

whisper_init_state: kv cross size =   55.30 MB

whisper_init_state: compute buffer (conv)   =   22.54 MB

 whisper_init_state: compute buffer (encode) =  2 80.20 MB

whisper_init_state: compute buffer (cross)  =    6.31 MB

whisper_init_state: compute buffer (decode) =   97.40 MB

 

system_info: n_threads = 4 / 8 | AVX = 1 | AVX2 = 1 | AVX512 = 0 | FMA = 1 | NEON = 0 | ARM_FMA = 0 | METAL = 0 | F16C = 1 | FP16_VA = 0 | WASM_SIMD = 0 | BLAS = 0 | SSE3 = 1 | SSSE3 = 1 | VSX = 0 | CUDA = 0 | COREML = 0 | OPENVINO = 0

 

main: processing '/home/codelast/st.wav' (23957094 samples, 1497.3 sec), 4 threads, 1 processors, 5 beams + best of 5, lang = zh, task = transcribe, timestamps = 1 ...

 

 

[00:00:00.000 --> 00:00:19.040]  这里是识别文字第一句

[00:00:19.040 --> 00:00:40.280]  这里是识别文字第二句
......

可以看到，输出的内容是带有时间轴标识的。
细看会发现，Whisper输出的中文有时会有错别字，我们可以用AI进一步纠错，想怎么处理你就可以随意发挥了。
文章来源：https://www.codelast.com/
➤➤ 版权声明 ➤➤ 
转载需注明出处：codelast.com 
感谢关注我的微信公众号（微信扫一扫）：

以及我的微信视频号：

 

本来嘛，点进这个页面，会看到正常的counter数据，但是，出问题的情况下，点进去看到的是这种情况：

同时，在shell命令行你也会发现，该job没有任何counter信息输出。
从错误信息页上，你得不到关于错误的任何有效信息，那个"Error Details"里也没有。
虽然counter无法显示，但M-R job是可以正常跑完、正常输出数据的。
文章来源：https://www.codelast.com/
经过测试，我这个case的的问题是：在程序中添加了数量比较多的Hadoop counter造成的。
什么算多？我不知道。我的程序里有240多个counter就出问题了，当我把counter缩减了一半，最终只有120多个counter的时候，counter信息统计就正常了。
如果你遇到了类似问题，可以首先检查一下job中的counter数量是否太多。
文章来源：https://www.codelast.com/
➤➤ 版权声明 ➤➤ 
转载需注明出处：codelast.com 
感谢关注我的微信公众号（微信扫一扫）：

以及我的微信视频号：

有时候，一个用了好久、一直好用的方法突然失灵，并且还折腾了几天，真的会逼疯人。
前几天我就遇到了这种破事：在Ubuntu开发机上自己升级IntelliJ idea到最新版之后，就无法再启动它。
启动时永远会崩溃，无论是重启系统、删除IntelliJ idea的本地缓存，或者使用回旧版，都无法再启动它（仿佛什么文件被"污染"了，再也回不去了），十分烦人。经过几天各种方法的尝试，终于解决了问题，我的解决办法不具有普适性，但如果你遇到了此类问题，或许可以为你提供一些解决思路。

OS：Ubuntu 20.04.6 LTS
JDK：1.8.0_382
原来安装的IntelliJ idea版本：idea-IC-232.8660.185
从JetBrains官网上下载的新版IntelliJ idea版本：idea-IC-233.14808.21
我当时不是利用IDE里的升级功能来升级的，而是自己下载了新版的压缩包，解压出来一个 idea-IC-233.14808.21 目录，直接进入 bin 目录下执行 idea.sh 来跑的新版。众所周知，这样跑起来之后，新版会自动把旧版里的配置引入进来，只要没有问题，是可以无缝切换到新版不需要重新配置的。
文章来源：https://www.codelast.com/
然而，启动新版的时候挂了，最后看到命令行报错：

[error occurred during error reporting (), id 0x6, SIGABRT (0x6) at pc=0x00007fed3c5cf00b]

Aborted (core dumped)

进不了IDE主界面。同时在/home目录下生成了一个内容超长的错误报告文件 java_error_in_idea_xxx.log
我一开始并没有看这个log文件，而是按网上搜到的方法，分别尝试了：
1、重启系统
2、删除IntelliJ idea的缓存
3、使用回旧版IntelliJ idea
4、仿照这个类似的问题，卸载了snap又重新安装
以上方法都没用。
实在没辙了，只能硬着头皮看崩溃产生的日志文件 java_error_in_idea_xxx.log，没想到一看就发现了端倪。
开头有一段内容是：

# Problematic frame:

# C  [x86_64-linux-gnu-tree-sitter-cpp.so+0x38ec09]  tree_sitter_cpp_external_scanner_deserialize+0x179

虽然我不知道它是什么确切的意思，但是这里写的是"问题帧"，说明崩溃和它有关。
文章来源：https://www.codelast.com/

再往下看日志，会看到：

---------------  T H R E A D  ---------------

 

Current thread (0x00007fec7c02b370):  JavaThread "AWT-EventQueue-0" [_thread_in_native, id=352672, stack(0x00007feb95ae5000,0x00007feb95be6000)]

 

Stack: [0x00007feb95ae5000,0x00007feb95be6000],  sp=0x00007feb95be0310,  free space=1004k

Native frames: (J=compiled Java code, j=interpreted, Vv=VM code, C=native code)

C  [x86_64-linux-gnu-tree-sitter-cpp.so+0x38ec09]  tree_sitter_cpp_external_scanner_deserialize+0x179

C  [x86_64-linux-gnu-tree-sitter.so+0x30b3e]  ts_parser_reset+0x30e

C  [x86_64-linux-gnu-tree-sitter.so+0x2e329]  ts_parser_set_language+0x399

C  [x86_64-linux-gnu-tree-sitter.so+0xb4875]  Java_org_treesitter_TSParser_ts_1parser_1set_1language+0x25

j  org.treesitter.TSParser.ts_parser_set_language(JJ)Z+0

j  org.treesitter.TSParser.setLanguage(Lorg/treesitter/TSLanguage;)Z+10

j  ai.codegeex.plugin.lang.agent.d.a()V+64

j  ai.codegeex.plugin.lang.agent.d.<init>()V+365

j  ai.codegeex.plugin.lang.agent.d.a()Lai/codegeex/plugin/lang/agent/d;+10

j  ai.codegeex.plugin.lang.agent.CodegeexAgentCompletionService.e()V+0

j  ai.codegeex.plugin.lang.agent.CodegeexAgentCompletionService.<init>()V+266

可见，和出问题的"x86_64-linux-gnu-tree-sitter-cpp.so+0x38ec09"有关系的插件，第一个出现的就是"ai.codegeex.plugin"，这个对应的就是我安装的CodeGeeX插件。

所以我怀疑，删除这个插件可以解决IntelliJ idea启动崩溃的问题。

在Ubuntu系统上，插件安装在这个目录下：~/.local/share/JetBrains/IdeaIC2023.3

其中，IdeaIC2023.3是IntelliJ idea的版本号，每升级一个版本，~/.local/share/JetBrains 目录下都会生成一个新的目录。

在这个目录下，会看到有一个名为"CodeGeeX"的目录，这个目录就是CodeGeeX插件的安装目录，删除它即可。

然后再次尝试启动IntelliJ idea，发现已经可以正常启动了。
虽然我现在还不知道为什么CodeGeeX插件会引起这个问题，但是如果你像我一样，实在找不到IDE崩溃的原因时，删除可能有问题的插件或许是解决问题的一个办法。
文章来源：https://www.codelast.com/
➤➤ 版权声明 ➤➤ 
转载需注明出处：codelast.com 
感谢关注我的微信公众号（微信扫一扫）：

以及我的微信视频号：

用Apache Pig处理大数据时，经常会有这种需求：把输入数据按指定的字段group，并且每个group内只输出时间最新的一条记录。

举个例子。有数据文件 input.txt ：

10      a       1,2,3
9       b       1,2
8       a       2,3,4
13      a       1,2,3,4
6       b       1

该数据的三个字段分别代表：time（时间戳），userId（用户id），userInterest（用户兴趣id）
现在，要找出每个用户时间最新的userInterest，应该怎么做？
即：对用户 a，最新的时间戳是13，userInterest是1,2,3,4；对用户 b，最新的时间戳是9，userInterest是1,2。
直接上代码：

A = LOAD 'input.txt' AS (time: long, userId: chararray, userInterest: chararray);
A = FOREACH A GENERATE time, userId, userInterest;
B = GROUP A BY userId;
-- 每个userId取时间最新的一条记录
C = FOREACH B {
    SORTED = ORDER A BY time DESC;
    ONE_RECORD = LIMIT SORTED 1;
    GENERATE FLATTEN(ONE_RECORD);
};
DUMP C;

在嵌套的FOREACH语句中，首先用ORDER BY对同一个group内的数据进行了降序排序，再用LIMIT取一条记录，由于是按time降序排序，因此LIMIT 1取到的就是时间戳最大的那条记录，即时间最新的记录。
输出：

(13,a,1,2,3,4)

(9,b,1,2)

可见这个结果和我们前面人工判断出来的正确结果一致。

文章来源：https://www.codelast.com/
➤➤ 版权声明 ➤➤ 
转载需注明出处：codelast.com 
感谢关注我的微信公众号（微信扫一扫）：

以及我的微信视频号：

在Apache Pig中，怎样把 2023-10-11_10:57:56 这种格式的时间字符串，转成整型的时间戳？
话不多说，直接上代码。
假设输入数据文件 1.txt，其格式是一行一个时间字符串。

A = LOAD '1.txt' AS (dt: chararray);
A = FOREACH A GENERATE ToDate(dt, 'yyyy-MM-dd_HH:mm:ss') AS date;
B = FOREACH A GENERATE ToUnixTime(date) AS ts;
DUMP B;

输出结果形如：

1696993076

可见，这样得到的时间戳单位是“秒”。
文章来源：https://www.codelast.com/
➤➤ 版权声明 ➤➤ 
转载需注明出处：codelast.com 
感谢关注我的微信公众号（微信扫一扫）：

以及我的微信视频号：

static class QuerySegmentResultFromKVReducer extends Reducer<Text, NullWritable, NullWritable, NullWritable> {

  @Override
  protected void setup(Reducer.Context context) throws IOException, InterruptedException {
  }

  @Override
  protected void cleanup(Reducer.Context context) throws IOException, InterruptedException {
  }

  @Override
  protected void reduce(Text key, Iterable<NullWritable> values, Context context) throws IOException, InterruptedException {
    //TODO:
  }
}

在这里，reducer输出的key、value类型都是NullWritable，我们不用关心，这不是本文的关注点。

如果reduce()方法漏掉了 @Override 注解，并且把  Reducer<Text, NullWritable, NullWritable, NullWritable> 错误地写成了 Reducer<Text, Text, NullWritable, NullWritable>，会发现编译并不报错。
但是，当你跑这个job的时候，诡异的事情就来了。你会发现，你在“TODO:”那里写的reduce逻辑并没有执行，即使没有用 context.write() 方法把任何数据输出到HDFS上，Hadoop counter仍然显示该job输出了和reducer输入一样多的数据。
从现象上看，就像是执行了一个默认的Reducer，把reducer的输入数据原样输出。
文章来源：https://www.codelast.com/
所以这里不得不强调，一定不要漏写 @Override 注解！有这个注解的时候，IDE就会提示错误，编译就会失败！

在本文的例子中，如果reduce()方法没有写 @Override 注解，那么当reducer类错误地定义成了extends Reducer<Text, Text, NullWritable, NullWritable>的时候，IDE并不会发现reduce()方法有错，从而让你误以为一切正常。
文章来源：https://www.codelast.com/
➤➤ 版权声明 ➤➤ 
转载需注明出处：codelast.com 
感谢关注我的微信公众号（微信扫一扫）：

以及我的微信视频号：

  -D "mapreduce.map.memory.mb=8192" \
  -D "mapreduce.reduce.memory.mb=8192" \
  -D "mapreduce.map.java.opts=-Xmx6144m" \
  -D "mapreduce.reduce.java.opts=-Xmx6144m" \

对Apache Pig M-R job，在Pig代码中添加如下语句：

SET mapreduce.map.memory.mb 8192;
SET mapreduce.reduce.memory.mb 8192;
SET mapreduce.map.java.opts -Xmx6144m;
SET mapreduce.reduce.java.opts -Xmx6144m;

其中，第1、2个参数需要你根据Hadoop集群的情况自行调整，第3、4个参数设置成第1、2个参数的70%～80%

文章来源：https://www.codelast.com/
➤➤ 版权声明 ➤➤ 
转载需注明出处：codelast.com 
感谢关注我的微信公众号（微信扫一扫）：

以及我的微信视频号：

{

 "model_version_status": [

  {

   "version": "1684833957",

   "state": "AVAILABLE",

   "status": {

    "error_code": "OK",

    "error_message": ""

   }

  }

 ]

}

其中，version就是我们要找的东西。
到你保存.pb模型的父目录下（可能是HDFS或本地磁盘），无脑搜version对应的关键字 1684833957，找到哪个目录，就是我们要找的.pb模型所在的目录。
通常这个目录下会有一个 saved_model.pb 文件，以及一个 variables 子目录。
为什么可以这样做？因为version里的时间戳就是导出 .pb 模型的时间戳，这个时间戳精确到秒，一般情况下，两个模型几乎不太可能在同一秒生成，所以这个时间戳是唯一的，因此只要能找到这个目录名，那么目录里的 .pb 模型几乎肯定是我们要找的模型。

文章来源：https://www.codelast.com/
➤➤ 版权声明 ➤➤ 
转载需注明出处：codelast.com 
感谢关注我的微信公众号（微信扫一扫）：

以及我的微信视频号：

HLS（HTTP Live Streaming）是一种基于HTTP协议的流媒体传输协议，而M3U8则是一种基于文本的播放列表文件格式。在HLS中，媒体数据被划分成多个小文件进行传输，并使用M3U8文件作为索引来指向这些媒体数据文件。M3U8文件包含了所有的媒体数据文件的URL地址及其相关信息，如码率、分辨率、编码格式等。因此，当一个客户端请求播放一个HLS流时，它将下载对应的M3U8索引文件，并且根据其中包含的地址去下载其他的媒体数据文件。简单来说，HLS和M3U8是两个不同但紧密相连的概念，其中M3U8作为HLS协议中索引与定位资源的重要组成部分。

问题来了：如何下载HLS流视频文件呢？

有多种方法，下面略举一二。

➤ 使用Chrome插件：Video DownloadHelper
这个插件可以捕获视频地址，也可以直接下载。但是直接下载HLS流视频每天有次数限制（很久以前是这样，不知道现在是什么情况），所以用此插件直接下载不可取。
那么我们可以用它获取视频地址，再用类似于 M3U8-Downloader 这样的桌面软件去下载这个地址指向的视频。
文章来源：https://www.codelast.com/
➤ 使用跨平台的HLS下载工具 N_m3u8DL-RE
N_m3u8DL-RE 是一款跨平台的DASH/HLS/MSS下载工具，功能很强大。
以Ubuntu Linux系统为例，只需简单地下载其release包，解压出来得到一个可执行程序 N_m3u8DL-RE，然后这样用就可以下载HLS流视频了：

./N_m3u8DL-RE <m3u8_url>

N_m3u8DL-RE 支持的参数非常多，可以参考其文档。
如果首次运行的时候提示没有安装 ffmpeg，可以用 apt install ffmpeg 安装，再运行。

文章来源：https://www.codelast.com/
➤➤ 版权声明 ➤➤ 
转载需注明出处：codelast.com 
感谢关注我的微信公众号（微信扫一扫）：

以及我的微信视频号：

在大数据处理流程中，TFRecord文件通常是由map-reduce job生成的，数据量通常很大。有时为了验证文件内容正确，我们需要取少量数据来检查，例如，我们可以拿map-reduce job生成的N个TFRecord文件中的一个，在本地解析出来，打印出其中的内容看是否正确。
下面就是一个用JAVA程序读取TFRecord文件并打印出其中一个Example的例子：

    String localTfRecordFile = "/path/to/your/tfrecord/file";
    InputStream inputStream = Files.newInputStream(Paths.get(localTfRecordFile));
    DataInput dataInput = new DataInputStream(inputStream);
    TFRecordReader reader = new TFRecordReader(dataInput, true);

    byte[] recordBytes = reader.read();
    while (recordBytes != null) {
      Example example = Example.parseFrom(recordBytes);
      System.out.println(example.toString());
      break;  // 只打印一个Example
    }
    inputStream.close();

唯一需要注意的就是一个引入：import java.nio.file.Paths;
文章来源：https://www.codelast.com/
再详细说明一下：