• 现在使用五笔输入法的人是越来越少了，像我一样在Linux系统上使用五笔的，就更是少得可怜。想当年，五笔输入法还是一个比较流行的输入法的时候，在Windows上有一个非常火爆的软件：极点五笔输入法。后来有人把它移植到了Linux系统，但这种没有大公司支持的项目，是没有持续更新支持的，所以，这么多年来，我一直使用着一个过时的词库，如果遇到词库里没有的专用词，我就自己用快捷键把它加到词库里，多年累积下来，也算是更新了一小部分词库。但实际上，还是有很多覆盖不到的词，比如原始词库连"支付宝"都不认识。
• 为了解决这个问题，我在AI的辅助下做了一些调研，并在此基础上对Ubuntu上使用的极点五笔输入法词库做了一次与时俱进的更新。
• 说得简单点，就是如下这个过程：从公网找词库 → 筛选 → 转成 fcitx4 二进制码表 → 校验 → 上线 → 回滚预案。
• 配套代码已开源：LINK
• 文中只展示核心代码片段；片段为示意节选，与仓库里的文件不完全逐行一致，请以仓库中的实际代码为准（每节标注了文件名并附链接）。
• 以下所有命令都假设你已克隆并进入仓库目录：
• git clone https://github.com/codelast/update-freewb-dict-on-linux.git && cd update-freewb-dict-on-linux
• 适用：fcitx 4.x + fcitx-table-wbpy（「五笔拼音」，词库源自极点五笔的极爽词库）。

0. 速览

本次实际成果（示例）：词库 312,315 → 336,897 条，新增五笔 10,203 条、拼音 14,378 条，原有记录零丢失。

文章来源：https://www.codelast.com/
仓库文件清单

下表文件均位于仓库 main 分支，点击文件名可直达源码。

1. 背景与原理

1.1 「极点五笔」在 Linux 上到底是什么

所以「更新极点五笔词库」在 Linux 上等于「替换 wbpy.mb 里的词条数据」。引擎、快捷键、皮肤、用户造词习惯全部不变，只是数据变了。

wbpy.conf 里几个决定格式的关键参数：

[CodeTable]
UniqueName=wbpy
Name[zh_CN]=五笔拼音
File=wbpy.mb
ExactMatch=False     ; 前缀匹配 → 拼音码被截断也照样能用
UsePY=False
PYKey=z

1.2 为什么不直接用文本编辑器

.mb 是 fcitx 私有的二进制表：头部含按键字符集、码长、组词规则，记录区是按码排序的定长头 + 变长词条。 用文本工具改，轻则加载失败，重则索引错乱（能启动但查不到词）。

文章来源：https://www.codelast.com/
2. 二进制格式（权威来源 + 实测）

2.1 源码位置

GitHub fcitx/fcitx（fcitx4，已归档）：

不要参考 nopdan/rose 的 format/fcitx4_mb：它假设码字段宽度 = codeLen + 1（=5），实际是 pyCodeLen + 1（本文示例 = 13）。按它的写法解析会整体错位一条记录。

2.2 文件结构

┌── 头部 ─────────────────────────────────────────────┐
│ u32  0                    新格式标志                  │
│ i8   version              3 = 当前版本（<3 为旧版）   │
│ u32  keyLen                                          │
│ u8   KeyCode[keyLen+1]    NUL 结尾，如 "abc...y"      │
│ u8   codeLen              码长（本文示例 4）          │
│ u8   pyCodeLen            拼音码长（本文示例 12）     │
│ u32  ignoreLen                                       │
│ u8   InvalidChar[ignoreLen+1]                        │
│ u8   hasRule             1 = 后面跟组词规则表         │
│ (codeLen-1) × [ u8 flag, u8 words,                   │
│                 codeLen × (u8 flag, u8 which, u8 idx) ]│
│ u32  recordCount                                     │
├── 记录区（按码排序，共 recordCount 条）──────────────┤
│ 每条：                                               │
│   码    pyCodeLen+1 字节（NUL 填充；本文 13 字节）    │
│   u32   词长（**含**结尾 NUL）                        │
│   词    UTF-8 字节 + NUL                             │
│   i8    type  0=五笔 1=拼音 2=自造词 3=提示           │
│   u32   iHit  用户命中次数（新词写 0）                │
│   u32   iIndex 全局递增序号（新词取 max+1）           │
└─────────────────────────────────────────────────────┘

2.3 三条硬约束（踩过才知道）

1. 记录必须按「码的首字符」分组排序。table.c（上游源码，仅阅读参考） 建索引时只比较 cChar != strCode[0]，顺序乱了就查不到。
2. 同码候选的先后 = 记录在文件里的先后。想让它排最后，就插到该码组的末尾；想排第一，插到组首。
3. 前 4 字节不是词长，而是码字段的第 5~8 字节。这是最容易搞错的地方（第一版解析器就栽在这）。

2.4 匹配行为（决定拼音码能不能截断）

tabledict.c::TableCompareCode() 只按用户输入长度逐字节比较，wbpy.conf 里 ExactMatch=False，所以是前缀匹配：

size_t tmp_len = strlen(strUser);
for (i = 0; i < tmp_len; i++) { if (strUser[i] != strDict[i]) return …; }
if (exactMatch && strlen(strUser) != strlen(strDict)) return -999;

含义：拼音码被截断到 12 字母也照样能用（打前几个字母就出候选）；五笔 4 码同理。

文章来源：https://www.codelast.com/
3. 工具链：编译官方 mb2txt

文件：build_mb2txt.sh（配合 tabledict.h、stub.c）

mb2txt.c（脚本自动下载） 只外部依赖一个 fcitx_utils_read_uint32，所以可以脱离 fcitx 开发环境单独编译。脚本做的事就是：放好极简头文件 → 下载官方 mb2txt.c → 用 stub 编译。

核心三行：

mkdir -p im/table && cp -f tabledict.h im/table/tabledict.h
curl -fsSL -o mb2txt.c https://raw.githubusercontent.com/fcitx/fcitx/master/tools/cli/mb2txt.c
gcc -O2 -I. -o mb2txt mb2txt.c stub.c

产出用法：

./mb2txt        ~/.config/fcitx/table/wbpy.mb > table.txt   # 二进制 → 文本
./mb2txt -o 旧版.mb > old.txt                               # 旧格式（version<3）

输出形如：

;fcitx Version 0x03 Table file
KeyCode=abcdefghijklmnopqrstuvwxy
Length=4
Pinyin=@
PinyinLength=12
Prompt=&
ConstructPhrase=^
[Rule]
e2=p11+p12+p21+p22
e3=p11+p21+p31+p32
a4=p11+p21+p31+n11
[Data]
a 工
a 戈
@a 阿          ← @ 开头 = type=1（拼音记录）

文章来源：https://www.codelast.com/
4. 从公网找词库 + 筛选

文件：filter_candidates.py

4.1 数据源（全部开源可下载）

4.2 两个词库的码字段怎么还原

白霜：词 \t 4字母码 \t 词频，直接用。 墨奇：词 \t "xx,ax xx,ax …" \t 权重，每段对应一个字、逗号前是该字前两码，按五笔词组规则还原：

def moqi_to_code(s):
    segs = [x.split(',')[0] for x in s.split()]
    n = len(segs)
    if n == 2:  return segs[0][:2] + segs[1][:2]
    if n == 3:  return segs[0][0] + segs[1][0] + segs[2][:2]
    return segs[0][0] + segs[1][0] + segs[2][0] + segs[-1][0]

（2 字=各前两码；3 字=首字首码+次字首码+末字前两码；4 字以上=前三字首码+末字首码）

4.3 质量判据：用「凝固度」把搭配垃圾挡在门外

拼音词库是给整句解码用的，天然塞满 有多、人是、的时候 这类高频二元组。它们对拼音输入有意义，对五笔是纯噪音。

• PMI（内部凝固度）：PMI = log2( P(w) / Π P(c) )，再除以 (词长-1) 做长度归一。
• 阈值怎么定：拿"本机已收录的 2 字词"反推分布——实测 P25 ≈ 5.0、中位数 ≈ 8.0 → 取 归一化 PMI ≥ 5.0。
• 对照：人是 -2.5、中有 -0.9、是最 -0.2、有多 1.7（都在底部分位）；题主 11.5、刷题 8.2、算力 6.8。

PMI 不是充分条件（的时候 PMI 18.1 也不是词），所以再叠三层：虚词字过滤 → 方位/副词短语过滤 → 词典交叉（把"确认是词"和"疑似新词"分成两档）。

核心片段（filter_candidates.py）：

def word_code(w):
    """用本机单字全码拼词码（比信外部词库更一致）"""
    cs = [wubi_single.get(ch) for ch in w]
    if any(not c for c in cs): return None
    if len(w) == 2:   r = cs[0][:2] + cs[1][:2]
    elif len(w) == 3: r = cs[0][0] + cs[1][0] + cs[2][:2]
    else:             r = cs[0][0] + cs[1][0] + cs[2][0] + cs[-1][0]
    return r if len(r) == 4 and r.isalpha() else None

def pmi(word, freq, tot_w):
    pc = 1.0
    for ch in word:
        if ch not in char: return None
        pc *= char[ch] / tot_c
    return math.log2((freq / tot_w) / pc) / max(1, len(word) - 1)

def keep(w):
    if set(w) & FUNC: return False                      # 含虚词字
    if len(w) >= 3 and w[-1] in LOC: return False        # 方位短语
    if len(w) >= 3 and w[0] in DEG: return False         # 副词开头
    if any(g in w for g in GLUE): return False           # 常见口语搭配
    return True

4.4 三次实际筛选结果（示例）

经验：2 字档噪音约 15%，3 字档约 25~30%，4 字档原始候选噪音六成（必须靠成语库/词表分档）。

文章来源：https://www.codelast.com/
5. 程序清单与核心逻辑

5.1 mb_table.py — 码表读写库（核心）

对外三个函数：read(path) -> Table、write(path, table)、insert_sorted(table, items)。

• read：按 2.2 的结构解析，最后断言 len(records) == recordCount（防格式判断失误）
• write：头部原样写回 + 记录逐条序列化（码左对齐 NUL 填充、词长含 NUL）
• insert_sorted：按码插入，同码插在组尾，iIndex 取全局 max 递增

insert_sorted 的核心（候选顺序 = 文件顺序，所以插入位置决定排第几）：

def insert_sorted(table, new_items):
    max_idx = max((r[4] for r in table.records), default=0)
    add = []
    for code, word, typ in new_items:
        max_idx += 1
        add.append([code, word + b'\x00', typ, 0, max_idx])
    add.sort(key=lambda r: (r[0], r[1]))

    out, i, ai, recs = [], 0, 0, table.records
    while i < len(recs):
        if ai < len(add) and add[ai][0] < recs[i][0]:
            out.append(add[ai]); ai += 1
        else:
            cur = recs[i]; out.append(cur); i += 1
            if ai < len(add) and add[ai][0] == cur[0]:   # 走到该码组末尾
                out.append(add[ai]); ai += 1
    out.extend(add[ai:])
    table.records = out
    return len(add)

5.2 merge_wubi.py — 并入五笔词条

读 CSV（至少含 词,五笔码），跳过表里已存在的词，调用 insert_sorted(..., type=0)。

have = {r[1].rstrip(b'\x00').decode('utf-8', 'ignore') for r in t.records}
items = [(row['五笔码'].encode(), row['词'].encode(), 0)
         for row in csv.DictReader(open(cand_csv, encoding='utf-8'))
         if row['词'] not in have]
n = mb_table.insert_sorted(t, items)
mb_table.write(dst, t)

用法：python3 merge_wubi.py <源.mb> <候选.csv> <输出.mb>

5.3 gen_pinyin.py — 生成拼音码（含多音字）

三个要点：词组级注音（避免多音字按单字乱读）、多音备选、按 pyCodeLen 截断。 关键设计：备选读音必须在"本机表里已出现过的单字读音"白名单内，否则会造出输入法根本打不出的废码。

# 1) 从 dump 里取单字读音白名单
local = collections.defaultdict(set)
for ln in body:
    if ln.startswith('@') and ' ' in ln:
        c, w = ln[1:].split(' ', 1)
        if len(w) == 1:
            local[w].add(c)

# 2) 词组级注音 + 按白名单过滤每个字的读音
base = ''.join(lazy_pinyin(w))[:12]
vs = pinyin(w, heteronym=True, style=Style.NORMAL)
vs = [[p for p in lst if p in local.get(ch, {p})] or lst for lst, ch in zip(vs, w)]

# 3) 组合候选，去重，最多保留 cap 个
for combo in itertools.product(*vs):
    p = ''.join(combo)[:12]
    if p not in cands: cands.append(p)
    if len(cands) >= cap: break

用法：python3 gen_pinyin.py <词表.csv> <输出.csv> <表dump.txt> [每词最多几个码]

5.4 merge_pinyin.py — 并入拼音记录

与 merge_wubi.py 同构，区别是 type=1，且支持跳过冲突码：

若某拼音码恰好等于一个"只有唯一候选"的五笔码，插入后会破坏"唯一即上屏"。这类码要放进跳过列表。

skip = set((sys.argv[4] if len(sys.argv) > 4 else '').split(','))
items = [(row['拼音码'].encode(), row['词'].encode(), 1)
         for row in csv.DictReader(open(py_csv, encoding='utf-8'))
         if row['拼音码'] and row['拼音码'] not in skip
         and (row['词'].encode(), row['拼音码'].encode()) not in existing]

用法：python3 merge_pinyin.py <源.mb> <拼音.csv> <输出.mb> [跳过的码,...]

5.5 filter_candidates.py — 候选筛选

输入：本机 dump + 字频表（chars.dict.yaml）+ 一个或多个外部词库文件；输出 CSV：词,五笔码,词频,归一PMI。 判据见第 4.3 节。

用法：python3 filter_candidates.py <dump.txt> <chars.dict.yaml> <词库1> [词库2 ...] > cand.csv

文章来源：https://www.codelast.com/
6. 安装与验证

6.1 为什么必须先停 fcitx

fcitx-table 在退出时会重写整个 .mb（把内存里的表 + 用户造词落盘）。只要 fcitx 还在跑，你替换的文件可能被覆盖，或它下次退出时把内存旧表写回去。 所以顺序必须是：停 → 备份 → 基于最新文件重建 → 替换 → 启动。

6.2 apply.sh：一键替换（已封装上述顺序）

./apply.sh <new_table.mb> [before.txt]

脚本内部的关键几步：

pkill -TERM -x fcitx; sleep 3                      # 1) 停（让它把用户词落盘）
cp -p "$MB" "$HOME/wbpy.mb.bak-$TS"                # 2) 备份
"$HERE/mb2txt" "$NEW" > after.txt                  # 3) 回读新表
ADD=$(diff <(sort before.txt) <(sort after.txt) | grep -c '^>')
LOST=$(diff <(sort before.txt) <(sort after.txt) | grep -c '^<')
[ "$LOST" = "0" ] || exit 1                        # 4) 有丢失就中止，不动原库
cp "$NEW" "$MB"; chmod 600 "$MB"                   # 5) 替换
setsid fcitx -d &                                  # 6) 启动

手工等价流程（不用脚本时）：

MB="$HOME/.config/fcitx/table/wbpy.mb"
pkill -TERM -x fcitx; sleep 3
cp -p "$MB" "$HOME/wbpy.mb.bak-$(date +%Y%m%d-%H%M%S)"
./mb2txt "$MB" > before.txt
python3 merge_wubi.py "$MB" cand_wubi.csv after.mb
./mb2txt after.mb > after.txt
diff <(sort before.txt) <(sort after.txt) | grep -c '^>'   # 新增条数
diff <(sort before.txt) <(sort after.txt) | grep -c '^<'   # 必须为 0
cp after.mb "$MB" && chmod 600 "$MB"
setsid fcitx -d &

• 无图形界面的 shell 里启动 fcitx 需带上会话变量：DISPLAY=:0、XAUTHORITY=$XDG_RUNTIME_DIR/gdm/Xauthority、DBUS_SESSION_BUS_ADDRESS=unix:path=$XDG_RUNTIME_DIR/bus。

• 注意 fcitx-remote 在没有输入焦点的 shell 里可能返回 0，不能当判据；用 xprop -root | grep XIM_SERVERS（应含 @server=fcitx）或直接打字判断。

6.3 三层验证

抽验示例：

五笔：iiid 泪流满面 / fiml 云淡风轻 / uspy 盖棺定论 / aflf 攻城略地
拼音：leiliuma → 泪流满面 / yundanfe → 云淡风轻 / zhifubao → 支付宝

6.4 回滚

./rollback.sh ~/wbpy.mb.bak-YYYYmmdd-HHMMSS

建议每批改动前都备份；确认稳定几天后只留最近一份（每个约 10MB）。

文章来源：https://www.codelast.com/
7. 经验与坑（按踩坑顺序）

1. 别信"码宽 = 码长 + 1"。真实是 pyCodeLen + 1（w bpy 表里是 13）。按 4/5 字节解析会整体错位，且因为同码相邻记录"看起来也对"，很难发现。
2. 前 4 字节不是词长。它是码字段的中间部分；词长在码字段之后。第一版解析器能 100% "重建"文件（因为原样拷贝了未知字节），但新记录建不出来 —— round-trip 一致性只能证明"读懂了"，不能证明"会写"。
3. 记录必须按码首字符分组，否则引擎索引失效。
4. 同码先后 = 文件先后，插入位置即候选位置。
5. iIndex 用全局最大值 +1，iHit 新词写 0，type：五笔 0、拼音 1（写错会被当拼音/提示记录）。
6. 拼音码截断到 pyCodeLen（12），但因为是前缀匹配，照样可用。
7. 拼音码若与"唯一候选的五笔码"同码，会破坏"唯一即上屏"，应跳过。
8. fcitx 退出会重写 .mb，所以顺序不能颠倒；重建要基于"停之后"的最新文件。
9. 拼音词库 ≠ 词表。有多/人是/的时候 是整句解码的 n-gram，必须靠 PMI + 词表交叉剔除。
10. 4 字词噪音最大，不要只按词频排；用成语库精确匹配效果最好。

8. 一次完整操作清单（checklist）

[ ] git clone https://github.com/codelast/update-freewb-dict-on-linux.git && cd update-freewb-dict-on-linux   # 拿到脚本
[ ] ./build_mb2txt.sh                        # 编译官方工具
[ ] ./mb2txt <词库.mb> > dump.txt             # 差集基准 + 单字码/读音来源
[ ] 下载外部词库（白霜 / 墨奇 / 现汉词表 / 成语库）
[ ] python3 filter_candidates.py ... > cand.csv
[ ] 人工抽验候选（TOP + 中段随机）
[ ] python3 merge_wubi.py   <源.mb> cand.csv  after.mb
[ ] 可选：python3 gen_pinyin.py / merge_pinyin.py
[ ] ./mb2txt after.mb > after.txt；diff 校验：新增对、丢失 0
[ ] ./apply.sh after.mb          # 停服→备份→校验→替换→重启
[ ] 日志无报错 + xprop 有 fcitx + 实打若干词
[ ] 记下备份路径与回滚命令

附：常用命令速查

以下命令均需在仓库目录下执行。

# 查看表结构（文本形式）
./mb2txt ~/.config/fcitx/table/wbpy.mb | head -20

# 统计词条数 / 拼音记录数
./mb2txt ~/.config/fcitx/table/wbpy.mb | sed -n '/
 $$Data$$ 
/,$p' | tail -n +2 | wc -l
./mb2txt ~/.config/fcitx/table/wbpy.mb | grep -c '^@'

# 按码查词
./mb2txt ~/.config/fcitx/table/wbpy.mb | grep '^rdug '

# 重启输入法
fcitx -r

全部操作只在 ~/.config/fcitx/table/（词库与备份）与仓库目录（脚本）内进行，不改动系统文件。

附：授权与合规（数据来源）

• 本项目代码以 MIT 发布（见仓库 LICENSE）。
• 本机自用（不分发）：GPL/MIT 的义务都不触发，无风险。
• 若要分发产出的 .mb：GPL-3.0 部分需提供生成脚本并同许可；MIT 部分保留版权声明；用户自定义词条版权归用户。

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

以及我的微信视频号：

有些Windows软件的技术栈真的好老

一个 2025 年 7 月发布的安装包，拆开一看，内核停留在 2008 年。

1、起因：只是想看看能不能搬到 Linux

事情很简单。我手上有一个 Windows 安装包 AxMath_Setup_Win_20250713_EN.exe（AxMath，一款小众的数学公式编辑器），我是它的正版注册用户，但我想着能不能在Ubuntu下，用非Wine的方式、非虚拟机的方式使用它呢？这就涉及把它移植到Ubuntu的问题了——如果它是基于Electron之类跨平台的框架开发的，那还真有可能。

文件名里写着 20250713，也就是 2025 年 7 月发布的版本。

所以就把它拆包看看。

2、拆开之后：考古现场

安装包是 NSIS 自解压格式，用 7z 一把就解开了：

7z x AxMath_Setup_Win_20250713_EN.exe -o extracted

里面的东西很有意思：

AxMath.exe        主程序
AxSnap.exe        截图/OCR 工具
Register.exe      授权注册
AxLaTeX.dll       LaTeX 渲染
AxBDH.dll         Office 桥接
Microsoft.VC90.MFC/mfc90u.dll      ← 注意这个
gdiplus.assembly/GdiPlus.dll
libeay32.dll / ssleay32.dll / libcurl.dll

Microsoft.VC90.MFC 这个目录名就是线索：VC90 = Visual C++ 2008。也就是说，这个 2025 年的软件，跑在 2008 年的运行时上。
文章来源：https://www.codelast.com/

再用 objdump 一验，实锤：

一边是 2025 年的时间戳，一边是 2008 年的工具链和 2015 年的第三方库。

3、2025年的软件版本竟然还是32位的

很多人的第一反应是：2025年的版本还是32位的？但对这类软件来说，这几乎是必然的。

3.1 迁移成本和收益不成比例 一个 MFC 老代码库要从 32 位迁到 64 位、从 VC9 迁到新工具链，构建脚本、第三方依赖、COM 注册……全都得动。而 32 位程序在 64 位 Windows 上靠 WOW64 照样跑，用户完全无感，对小软件团队来说没动力迁移。

3.2 Office 加载项的"位数枷锁" AxMath 的核心价值是嵌进 Word / Excel / WPS。它的 COM 组件必须和宿主 Office 的位数一致，而 32 位 Office / WPS 装机量巨大——跟着做 32 位最省事。解包里能看到一堆加载项：

AxMath.dotm   → Word（含 VBA 宏）
AxMath.xlam   → Excel
AxMath.ppam   → PowerPoint
WPS/STARTUP/AxMath.dotm → WPS

3.3 轻量应用根本用不上 64 位的好处 一个公式编辑器，内存占用远不到 2GB。64 位最大的优势（大内存寻址）在这儿毫无意义。
文章来源：https://www.codelast.com/

4、安全问题

技术栈老，本身只是"不优雅"。但当我们把范围从"好不好看"换成"安不安全"，问题就严肃了。

4.1 授权走的是明文 HTTP Register.exe 里的联网地址是（注意是 UTF-16 宽字符存的，普通搜索搜不到）：

http://www.axmath.cn:6150/@@@     ← 授权服务器
http://121.199.3.143:6150/@@@     ← 硬编码备用 IP

激活码、机器指纹，就这么明文发出去了。在公共 WiFi 下，同网段的攻击者抓个包就能拿到激活码——不需要任何漏洞利用技巧。

4.2 2015 年的 OpenSSL 1.0.2d 这个版本之后修的所有 CVE 它都带着。比如 CVE-2016-2107（AES-NI padding oracle），中间人可以利用它解密 HTTPS 会话——也就是说，"用了 HTTPS"在这个版本上并不等于安全。

4.3 承载漏洞的库没开内存防护

名词解释：

• ASLR（Address Space Layout Randomization，地址空间布局随机化）：每次程序启动时，把代码、数据、DLL 等加载到随机的内存地址。这样攻击者就无法预知某个函数或数据的固定地址，构造可靠的利用会变得困难。
• DEP（Data Execution Prevention，数据执行保护，即 NX）：把内存里的数据区标记为"不可执行"。即使攻击者把恶意代码写进了内存，CPU 也会拒绝执行它，从而挡掉一大类"写入即执行"的攻击。

一旦 libcurl（7.45.0 存在越界写类漏洞，如 CVE-2016-8617）或 OpenSSL 触发内存破坏，这个"裸奔"的 DLL 会让利用门槛大幅降低。
文章来源：https://www.codelast.com/
➤➤ 版权声明 ➤➤ 
转载需注明出处：codelast.com 
感谢关注我的微信公众号（微信扫一扫）：

以及我的微信视频号：

• 背景：你是否遇到过"树莓派的WiFi连不上网络，有线连接树莓派也不具备条件"的情况？这个时候，你想通过终端连接到树莓派上还剩下哪些选择？串口就是其中一个可行的办法。对大多数人来说，这种连接方法都算比较少见，但它确实是一个在网络断链时的好方法。
• 目标：让 macOS 通过 USB-TTL (CH340) 模块连接树莓派 GPIO 串口，获得一个完全不依赖网络的终端/登录通道（等同于 SSH 控制台，但走串口线）。
• 树莓派版本：3B Rev 1.2

1. 先认识 CH340 模块：它是什么，能帮我们做什么

1.1 CH340 是什么

CH340 是一颗国产的"USB 转串口"芯片（这类芯片也常被叫做 USB-UART 桥接芯片）。市面上卖的那种USB-TTL 小板，核心就是这颗芯片，板上通常还会引出一排针脚，标着 VCC / 5V / 3V3 / TXD / RXD / GND。

下面是我用AI绘制的CH340模块3D图：

下面是我的实拍图：

它做的事情可以一句话讲清楚：把你的电脑 USB 口变成一个"串口"。电脑这边看到的是一个串口设备，另一端（比如树莓派、单片机）看到的是标准的串口信号，CH340 负责在两者之间翻译数据。这样电脑就能通过串口协议和另一台设备互相收发数据了。

关于驱动

三个主流系统（Windows / macOS / Linux）都有 CH340 的驱动，多数情况下插上就能用，不需要手动装。

macOS 这边，驱动生效的标志是：系统里出现一个叫 /dev/cu.usbserial-XXX 的设备文件。你可以把它理解成"串口的门牌号"——终端程序（比如我们后面要用的 screen）就是靠打开这个文件来跟串口通信的。名字里的 XXX 是一串数字，每次插拔可能不一样。所以你插上 CH340 后，先执行下面这条命令确认一下设备在不在：

ls /dev/cu.usbserial*

能看到类似 /dev/cu.usbserial-110 的输出，就说明驱动没问题，可以继续往下走了。如果什么输出都没有，那多半是驱动没装好。
文章来源：https://www.codelast.com/

关于电平（电压标准）

串口信号的电平有两种常见标准：5V 和 3.3V。树莓派的 GPIO 是 3.3V 逻辑，所以接树莓派时要注意别让 5V 电平直接灌进 GPIO 引脚。CH340 小板一般 3.3V/5V 都兼容，本文的接法只用到 TXD、RXD、GND 三根线，不涉及供电脚，所以只要别把 5V 引脚接到树莓派上就行（后面 2 章会细说）。

1.2 用它连树莓派，具体能做什么

1.3 为什么把它定位成"备用通道"，而不是日常主力

• 慢。9600 波特率换算下来每秒大约只有 0.8KB，敲命令、改配置够用，传文件会等到怀疑人生；
• 电脑得用一根 USB 线物理连着树莓派附近，人不在旁边就用不了；
• 日常调试当然还是 WiFi/网线 SSH 舒服，串口的意义在于：当网络这条路彻底断了，你还有一条路能进系统。

2. 硬件准备与接线

2.1 需要准备的东西

2.2 接线规则：交叉 + 共地（最容易错的一步）

先解释一下串口的两根数据线：

• TXD：发送（Transmit）——这根线负责"说"；
• RXD：接收（Receive）——这根线负责"听"。

通信要成立，必须一方的发送接到另一方的接收，也就是交叉接：

三个容易踩的坑：

1. TXD 和 RXD 必须交叉，绝不能 TXD 对 TXD。 如果接成 TXD 对 TXD，两边都在"说"、没人"听"，结果就是完全收不到任何数据。记住这个画面：两个人都只对着对方说话、却都把耳朵捂上，谁也听不见谁。
2. GND 必须共地。 意思是 CH340 的地线和树莓派的地线要连在一起，让两边有共同的电压参考点。如果不共地，表现是完全没有输出，或者收到一堆乱码（最常见的现象是收到 0 字节）。这一步看着不起眼，实际上一大半"没反应"的问题都出在它身上。
3. 不要把 VCC / 3V3 / 5V 接到树莓派上。 树莓派自己有电源，CH340 小板靠 USB 口供电，两边电源脚对接会造成双电源冲突，严重时可能烧东西。

另外，杜邦线插拔多了容易接触不良。如果怀疑接触问题，换一根线、或者重新插紧往往就好了。
文章来源：https://www.codelast.com/

2.3 接线示意图

下面这张图把树莓派 40-pin 排针全部画出来了。排针是竖着排列的：左边一列是奇数号 1、3、5…，右边一列是偶数号 2、4、6…，从上往下递增。蓝色高亮的是我们真正用到的三个脚。

图中三个高亮触点分别是：

• Pin 8：树莓派的 TXD（GPIO14）——接 CH340 的 RXD；
• Pin 10：树莓派的 RXD（GPIO15）——接 CH340 的 TXD；
• Pin 20：GND——图里选它只作示例，实际上树莓派上一堆 GND 脚（Pin 6/9/14/20/25/30/34/39）任选一个接都行。

再次强调：CH340 的 TXD 必须接树莓派的 RXD，CH340 的 RXD 必须接树莓派的 TXD，其他引脚一律不接。

3. 树莓派端要改的配置

要让树莓派通过 GPIO 串口提供登录服务，需要改三个系统文件。因为本文假设的场景是"树莓派已经没有任何网络连接"，所以先讲怎么在没有网络的情况下修改这些文件，再逐个讲每个文件改什么。
文章来源：https://www.codelast.com/

3.1 没有网络时怎么改系统文件（拔卡方式）

先认识要改的三个文件：

这里有个背景知识需要先说明：树莓派的 SD 卡（TF 卡）其实分成两个分区。一个是 boot 分区，格式是 FAT32，里面放的是开机要用的配置文件（config.txt、cmdline.txt 都在这里）；另一个是 系统分区，格式是 ext4，装着整个操作系统。FAT32 分区在任何电脑上都能直接读写，而 ext4 分区普通电脑默认是看不到的。

拔卡修改的具体步骤：

1. 关机断电：先在树莓派上正常关机，然后断开电源。切记不能带电拔卡，容易损坏文件系统；
2. 取出 TF 卡，用读卡器插到电脑上；
3. 改 boot 分区的文件：boot 分区是 FAT32，插上后电脑会直接识别。macOS 下它会自动挂载成一个盘，一般叫 /Volumes/bootfs，直接用文本编辑器打开里面的 config.txt、cmdline.txt 修改保存就行；Windows、Linux 同理，打开 TF 卡对应的盘符/挂载点就能看到这两个文件；
4. 系统分区里的文件：如果你需要改第三个文件（serial-getty 的 override），它在 ext4 系统分区里，普通电脑默认看不到。macOS 要用 debugfs 之类的 ext4 工具（需要 root 权限），Windows 可以用 ext2fsd 之类的软件。如果觉得这一步麻烦，可以先跳过它——先只改 boot 分区里的两个文件，等接上串口发现确实登录不了，再回头处理 3.4 节的问题；
5. 安全弹出 TF 卡（macOS 里右键推出），插回树莓派，重新上电。

两个容易困惑的点，提前说明：

• 路径差异：新版 Raspberry Pi OS（Debian 12/13）里，boot 分区在系统内挂在 /boot/firmware/；老版本是挂在 /boot/。但不管系统内路径怎么写，文件本身就在 boot 分区根目录里——你拔卡插电脑后，直接看盘符根目录下有没有 config.txt 就行，不用管 /boot/firmware 这种路径。
• 全新卡 vs 用过的卡：如果你是刚烧录好系统、还没第一次开机的卡，也可以插电脑直接改 boot 分区，效果和改 /boot/firmware/ 一样；如果是已经用过的卡，改之前一定要先正常关机再拔。

3.2 启用 GPIO 串口，并决定用哪个 UART

树莓派 GPIO 上引出的串口默认是关闭的，需要在 /boot/firmware/config.txt 里打开它。用文本编辑器打开这个文件，在文件末尾追加：

enable_uart=1

光打开还不够，树莓派 3 上有个特殊情况需要决定：这颗芯片其实有两个串口硬件——一个叫 PL011（质量好、波特率准，但默认分配给蓝牙用），一个叫 mini-UART（功能弱一些、波特率会随 CPU 频率漂移）。GPIO 引出的串口到底用哪个，由要不要给蓝牙让路决定。有三个方案：

怎么选，取决于你要不要蓝牙：

• 还要用蓝牙：选方案 3。GPIO 串口会是 /dev/serial0 -> ttyS0（mini-UART）。因为 mini-UART 的波特率会随 CPU 频率漂移，建议把波特率定在 9600 这种低速档，或者去固定 CPU 频率，否则可能出现乱码；
• 不需要蓝牙，只想要最稳定的串口：选方案 1。GPIO 串口是 /dev/serial0 -> ttyAMA0（PL011），波特率精确，省心。

后面各小节的命令都以 方案 3（设备名 ttyS0） 为例。如果你选了方案 1，把命令里出现的 ttyS0 全部换成 ttyAMA0 即可。

顺带一提：/dev/serial0 是一个软链接，它总是指向"当前 GPIO 串口实际对应的那个设备"（ttyS0 或 ttyAMA0），所以不确定时先执行 ls -l /dev/serial0 看一眼它指向谁，心里就有数了。

3.3 让内核把启动信息输出到串口（顺便定波特率）

Linux 内核启动时的日志默认是输出到屏幕的。我们希望它同时也输出到 GPIO 串口，这样就算树莓派没接屏幕，也能从串口看到启动过程。

这个行为由 /boot/firmware/cmdline.txt 控制。用文本编辑器打开它，确认里面有这样一段（注意是 serial0，不是别的）：

console=serial0,9600

serial0 就是 GPIO 串口的软链接名，9600 是波特率。如果文件里同时有 console=tty1 之类的（那是输出到本地屏幕的），不要删掉它们，只把 serial0 这一段波特率定为 9600 就好。

波特率这个东西，后面会反复强调：发送端和接收端必须用同一个波特率，否则收到的就是乱码。

3.4 让系统在串口上启动登录程序（serial-getty）

前面两步只是让内核往串口输出日志，但光有日志还不能登录。要登录，系统里得有一个程序在串口上等着，显示 login: 提示符、接受你输入用户名密码——这个程序叫 getty，对应的系统服务是 serial-getty@<串口设备>.service。

树莓派系统在检测到 GPIO 串口启用后，一般会自动启动对应的 serial-getty 服务。但有一个很常见的坑：getty 的波特率必须和内核 console 的波特率一致（都是 9600）。如果登录提示符不出现，多半就是 getty 没启动，或者波特率不对。

手动确认/修正的方法是给 getty 写一个配置文件，强制指定设备和波特率。在树莓派上创建 /etc/systemd/system/serial-getty@ttyS0.service.d/override.conf（目录可能要自己建）：

[Service]ExecStart=ExecStart=-/sbin/agetty --noclear --keep-baud ttyS0 9600 vt100

如果你的 GPIO 串口实际是 ttyAMA0（方案 1），就把上面两处 ttyS0 换成 ttyAMA0，文件名也跟着改成 serial-getty@ttyAMA0.service.d/override.conf。

然后重新加载 systemd 并启用服务：

sudo systemctl daemon-reloadsudo systemctl enable --now serial-getty@ttyS0.service

验证服务确实在跑：

systemctl is-active serial-getty@ttyS0   # 应该输出 activesystemctl list-units | grep ttyS0        # 能看到 serial-getty 在运行

到这里，树莓派端的配置就齐了：GPIO 串口已启用、内核往串口输出日志、getty 在串口上等你登录。

4. macOS 这一端怎么连

4.1 先确认设备名

CH340 插上后 macOS 会自动给它分配一个设备文件，名字是 /dev/cu.usbserial-XXXX（也可能是 /dev/tty.usbserial-XXXX）。注意末尾那串数字每次重新插拔都可能变（比如这次是 11310，下次变成 11320，再下次是 110），所以别死记一个名字，每次用之前先查一下：

ls /dev/cu.usbserial*

如果这条命令什么都查不到，说明驱动没装好，去 WCH 官网装 macOS 驱动。

4.2 用 screen 连上去

macOS 自带的 screen 命令就能当串口终端用：

screen /dev/cu.usbserial-110 9600

格式是 screen 设备文件 波特率，把设备名换成你上一步查到的实际名字。连接成功后，按一下回车，应该能看到：

rpi login:

输入树莓派的用户名和密码，就进入 shell 了，用法和 SSH 完全一样。

退出 screen 的方法：先按 Ctrl+A，松开后再按 K，最后按 y 确认退出。

4.3 不想开终端？也可以用命令直接收发

如果你是脚本/程序要自动化测试串口，不需要交互式终端，可以用下面的方式非交互地验证：

DEV=/dev/cu.usbserial-110                       # 换成你实际的设备名stty -f "$DEV" 9600 raw -echo                   # 设置波特率 9600，关闭回显(timeout 4 cat "$DEV" > /tmp/rx.txt &)          # 后台启动一个读取，读 4 秒printf '\r' > "$DEV"                            # 往串口写一个回车，触发登录提示cat /tmp/rx.txt                                 # 查看收到的内容，应该能看到 "rpi login:"

stty 负责配置串口参数，cat 负责读，printf 负责写——把串口当成一个文件来读写就行。

5. 调试记录：踩过的坑

下面这些是实际接线、调通过程中遇到的问题。如果你一次就成功了，可以跳过本章；如果哪里不对，按顺序排查通常能解决。
文章来源：https://www.codelast.com/

5.1 第一次接上：完全没有输出，或者全是乱码

刚接上时最常见的两个现象：读串口读到 0 字节（什么都没有），或者读到 40~70 字节的乱码。

按下面的顺序排查：

第 1 步：先确认 CH340 小板本身是好的（环回测试）

把 CH340 和树莓派的接线全部断开，然后用一根杜邦线把 CH340 板上的 TXD 和 RXD 短接（直接连在一起）。这样一来，CH340 自己发出去的数据会原路回到自己。然后用 screen 连上串口随便敲几个字：如果敲什么回显什么，说明 CH340 小板、USB 线、驱动这一整条链路都是好的，问题出在树莓派那一侧。

不想开终端的话，也可以用命令自动验证：

stty -f $DEV 115200 raw -echo(timeout 8 cat $DEV > /tmp/loop.txt &)   # 后台读printf 'HELLO_LOOP' > $DEV                # 写入一串测试文字grep HELLO_LOOP /tmp/loop.txt && echo OK   # 能在读到的内容里找到它 => 模块正常

如果这步通过，说明小板没问题，继续看第 2 步。

第 2 步：检查 GND 是否共地、TXD/RXD 是否交叉

读到的字节数是 0 时，优先怀疑两件事：GND 没接（换一个 GND 引脚试试），或者 TXD/RXD 没交叉。我实际遇到过：把 GND 从 Pin 30 换到 Pin 20 之后，读到的数据从 0 字节一下子变成 182 字节——共地的影响就是这么明显。

第 3 步：把 TXD 和 RXD 两根线对调

如果前面都查过还是没数据，把 TXD、RXD 两根线互换位置再试。很多时候数据从无到有，就差这一下。

5.2 有数据了，但是全是乱码 → 波特率不对

现象：能收到数据了，但内容完全没法看，全是乱码；而且换了好几档波特率读出来的都是"长度差不多的乱码"。

这是因为两边的波特率不一致。串口通信里，发送方和接收方必须用同样的波特率（相当于约定同样的说话语速），否则对方听到的就是无意义的声音。

推荐用"矩阵测试"来找到正确的波特率：树莓派和 macOS 两边同步切到同一个波特率，树莓派持续发一段特征文字，macOS 在另一边读，看哪一档能读出可读的文本。

树莓派侧（示例用 9600）：

sudo stty -F /dev/ttyS0 9600 raw -echo        # ttyS0 或 ttyAMA0，按你实际设备名for i in 1 2 3 4; do echo -n "MATRIX_BAUD_9600_$i" > /dev/ttyS0; sleep 0.2; done

macOS 侧：

stty -f $DEV 9600 raw -echo(timeout 4 cat $DEV > /tmp/mx.txt &)grep MATRIX_BAUD /tmp/mx.txt && echo 通过

我实际测试的结果是：9600 波特率下两边完全互通，反而 115200 读出来是乱的——这块 CH340 小板在 115200 这个高速档上精度不稳。所以最后统一把波特率定在 9600（8 数据位、无校验、1 停止位，也就是常说的 8N1），内核 console、getty、macOS 端全部用 9600。

5.3 能看到内核日志，但没有 login 提示 → getty 没起来

现象：串口上能看到内核启动的日志，但日志播完就没了，一直没有 login: 提示符。

这说明问题不在硬件，而在系统这边——没有程序在串口上等你登录，也就是 3.4 节说的 getty 没有正确启动，或者它的波特率和 console 不一致。解决办法就是按 3.4 节写好 override 文件、启用对应的 serial-getty@<设备>.service。

5.4 换了个 USB 口，就连不上了 → 设备名变了

现象：之前明明连得好好的，换了个 USB 口再插，screen 报错 [screen is terminating]。

原因在 4.1 节说过：设备名末尾的数字每次插拔都可能变。换了 USB 口，旧名字就失效了。解决办法很简单：重新执行 ls /dev/cu.usbserial* 查出新的设备名，用新名字重新连接。

6. 最终验证（确认可用）

配置全部完成后，用下面两条验证整个链路是通的。
文章来源：https://www.codelast.com/

交互式验证（macOS 终端里）：

screen /dev/cu.usbserial-110 9600# 应该看到 rpi login:，输入用户名密码进入 shell

非交互式验证（脚本里用）：

printf '\r' > $DEVtimeout 5 cat $DEV        # 应该能看到 "rpi login:"

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

以及我的微信视频号：

系统：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 
感谢关注我的微信公众号（微信扫一扫）：

以及我的微信视频号：