Parquet 文件入门 Python 读写 Parquet 文件实战 大数据存储优化：Parquet 格式解析 Python 数据分析必备：Parquet 文件处理技巧 列式存储揭秘：Parquet 文件与性能优化 使用 Python 和 PyArrow 处理嵌套 Parquet 数据 从 CSV 到 Parquet：Python 数据格式转换教程

什么是 Parquet 文件？

Parquet 是一种列式存储文件格式，优化用于大规模数据处理。它常用于 Apache Spark、Hadoop 和 Pandas 等大数据框架，以实现高效存储和快速检索表格数据。 Parquet 格式可以简单认为是CSV的转置/Transpose。不过CSV是文本的，而Parquet是二进制的。从存储方式上理解列式存储就像把行列交换，但需要注意 Parquet 是二进制、支持压缩和嵌套类型，不仅仅是“转置”。

为什么使用 Parquet？

• 列式存储：按列存储数据，提高分析任务的查询性能。
• 压缩：支持高效的压缩技术，减少存储空间。
• 兼容性：可与多种数据处理框架配合使用。
• 模式演进：支持增加或删除列而不破坏现有数据。

安装所需库

要在 Python 中使用 Parquet，需要 pandas 和 pyarrow（或 fastparquet）：

pip install pandas pyarrow

在 Python 中读取 Parquet 文件

以下示例演示如何使用 pandas 和 pyarrow 读取 Parquet 文件：

import pandas as pd
import pyarrow.parquet as pq

# Parquet 文件路径
file_path = "example.parquet"

# 读取 Parquet 文件到 DataFrame
df = pd.read_parquet(file_path)

# 显示前 5 行
print(df.head())

写入 Parquet 文件

你也可以轻松地将 DataFrame 保存为 Parquet 文件：

import pandas as pd

# 创建示例 DataFrame
data = {
    "name": ["Alice", "Bob", "Charlie"],
    "age": [25, 30, 35],
    "city": ["London", "Paris", "New York"]
}
df = pd.DataFrame(data)

# 保存为 Parquet
df.to_parquet("output.parquet", engine="pyarrow", index=False)

处理嵌套数据

Parquet 支持嵌套数据，如列表或结构体。可以使用 pyarrow 直接读取：

import pyarrow.parquet as pq
from io import BytesIO

# 直接读取 Parquet 文件
table = pq.read_table("example.parquet")
df = table.to_pandas()
print(df.head())

总结

Parquet 文件在存储和处理大规模表格数据时非常高效。使用 Python 的 pandas 和 pyarrow，你可以轻松地读取、写入并处理 Parquet 文件，用于数据分析、ETL 流程和大数据应用。 [show_file file="/var/www/wp-post-common/justyy.com/python.php"] 英文：Introduction to Parquet Files: Read & Write using Python

使用原子 TAS 指令实现自旋锁

使用原子 TAS 指令实现自旋锁 Implementing a Spinlock Using the Atomic TAS Instruction 从零实现自旋锁：基于 TAS 的最小同步原语 Building a Spinlock from Scratch with Atomic TAS 用 test-and-set 实现最简单的互斥锁 Implementing a Minimal Mutex Using Test-and-Set 自旋锁的底层原理：TAS、原子性与忙等待 Inside Spinlocks: TAS, Atomicity, and Busy Waiting 原子操作与自旋锁：用 C 语言实现线程同步 Atomic Operations and Spinlocks: Thread Synchronization in C 从原子指令到锁：全面理解 TAS 和自旋锁 From Atomic Instructions to Locks: A Complete Guide to TAS and Spinlocks 动手写一个自旋锁：tryLock / lockAcquire / lockRelease 全实现 Hands-On Spinlock Implementation: tryLock, lockAcquire, and lockRelease 你的第一个自旋锁：基于 C 语言的 TAS 实现 Your First Spinlock: A TAS-Based Implementation in C 原子交换与线程互斥：自旋锁实现指南 Atomic Exchange and Thread Mutual Exclusion: A Guide to Implementing Spinlocks

假设我们有一个 TAS（Take-And-Set）函数。该操作返回内存中原来的值，并以原子方式将其替换为新值。原子性（atomicity）意味着没有其他线程能够观察到中间状态；整个读-写操作是一体不可分的。 在 C++ 中，标准库函数 std::exchange 在逻辑上表现相同，但它不是原子操作。同步原语需要硬件级别的原子性。

int TAS(int* memory, int newVal) {
    int old = *memory;
    *memory = newVal;
    return old;
}

我们想使用这个原语来实现一个简单的自旋锁，包括：

• lockAcquire()
• lockRelease()

线程将调用这些函数来保护对共享变量的访问：

typedef struct {
    int lock;
} lockType;

typedef struct {
    int val;
} threadArgType;

void threadFunc(void* arg) {
    lockAcquire((static_cast<lockType*>arg)->lock);
    (static_cast<threadArgType*>arg)->val++;
    lockRelease((static_cast<lockType*>arg)->lock);
}

实现 tryLock

tryLock 函数尝试获取锁一次。如果锁为空（值为 0），TAS 将其设置为 1 并返回原值（0）。如果锁已被占用，TAS 返回 1。tryLock 函数是非阻塞的——它会立即返回。 因此 tryLock() 只有在 TAS 返回 0 时才会成功：

enum {
    UNLOCKED = 0,
    LOCKED = 1
}

int tryLock(lockType* lock) {
    // 如果之前已锁定返回 1，如果之前未锁定返回 0
    int old = TAS(lock->lock, LOCKED);
    return (old == UNLOCKED);   // true (1) = 成功获取锁
}

实现 lockAcquire()

普通的锁获取应当“自旋”直到 tryLock() 成功。这称为 自旋锁，因为 CPU 会忙等待。必要时可以加入短暂的 sleep。例如，sleep(0) 并不会真正暂停执行，而是让出 CPU，允许其他线程运行。 它通常用于实现跨线程的互斥自旋锁。

void lockAcquire(lockType* lock) {
    while (!tryLock(lockType* lock)) {
        // 自旋直到锁可用
    }
}

另一种实现：

void lockAcquire(lockType* lock) {
    do {
       if (tryLock(lockType* lock)) {
          break;
       }
    } while (1);
}

展开 tryLock：

void lockAcquire(lockType* lock) {
    do {
       int old = TAS(lock->lock, LOCKED);
       // 无论锁是否已被获取，锁都已设置为 LOCKED
       if (old == UNLOCKED) {
           break;
       }
    } while (1);
}

这是使用 TAS 实现的最简单方法。在实际系统中，我们可能会加入 pause 指令或退避策略，但基本思路是相同的。

实现 lockRelease()

释放锁时，持有者只需将锁变量写为 0。由于 TAS 是“设置新值并返回旧值”，它同样适用于释放锁：

void lockRelease(lockType* lock) {
    TAS(lock->lock, UNLOCKED);
}

或者使用简单的原子存储也足够，但由于 TAS 是我们唯一的工具，我们重用它。请注意，在这里重复释放锁是安全的，因为再次将其设置为 UNLOCKED=0 不会产生副作用。

总结

仅使用原子 TAS 指令，我们实现了：

• 一个 tryLock() 尝试
• 一个 lockAcquire() 自旋锁
• 一个 lockRelease() 解锁操作

这种锁的实现方式对于理解低级并发、内存顺序以及高层互斥锁库的构建方式非常基础。 [show_file file="/var/www/wp-post-common/justyy.com/cpp.php"] 英文：Implement a Lock Acquire and Release in C++

Amdahl 定律 vs Gustafson 定律 — 完整教程、推导、应用场景及 Python 绘图

Amdahl 定律 vs Gustafson 定律：完整教程、推导、应用场景及 Python 绘图 理解并行加速：通过代码讲解 Amdahl 定律和 Gustafson 定律 并行计算基础：Amdahl 定律、Gustafson 定律及加速建模 并行加速原理：Amdahl 和 Gustafson 定律完整指南 并行扩展解析：推导并比较 Amdahl 和 Gustafson 定律 Amdahl vs Gustafson：并行加速完整指南（含 Python 代码） 并行性能建模：Amdahl 定律、Gustafson 定律及实际应用 学习并行加速：数学、直觉、应用场景及 Python 可视化 并行计算：必须掌握的两条定律（Amdahl & Gustafson） 工程师的并行加速：Amdahl 定律、Gustafson 定律及 Python 实现 从理论到代码：用 Amdahl 和 Gustafson 建模并行加速 实用并行加速指南：Amdahl 定律、Gustafson 定律及可视化 为什么并行不是无限的：简单解释 Amdahl vs Gustafson 并行加速真相：Amdahl 限制 vs Gustafson 扩展 并行计算神话与现实：Amdahl 和 Gustafson 的教训

引言

并行计算在现代计算中至关重要：多核 CPU、GPU、分布式集群、云工作负载、LLM 训练以及 HPC 模拟。 为了分析程序在更多处理器下能加速多少，主要有两种数学模型：

• Amdahl 定律 — 固定规模工作负载的性能
• Gustafson 定律 — 可扩展规模工作负载的性能

这两条定律并不矛盾，它们回答的是 不同的问题。 本教程涵盖推导、直觉、比较、实际应用场景，以及展示两条定律的 Python 绘图脚本。

1. 什么是加速比？

加速比衡量程序在 N 个处理器上运行速度提升多少： [math]S(N) = \frac{T_1}{T_N}[/math] 如果程序在一个处理器上运行 10 秒，两处理器运行 5 秒，则加速比为： [math]S(2) = \frac{10}{5} = 2[/math] 完美线性加速为： [math]S(N) = N[/math] 但实际系统存在串行瓶颈，这正是 Amdahl 定律和 Gustafson 定律描述的内容。

2. Amdahl 定律（固定工作量）

2.1 直觉

Amdahl 假设：

• 总工作量保持 不变
• 部分工作是串行的，无法并行化

设：

• f = 串行比例
• 1 - f = 可并行比例

2.2 推导

一个处理器的运行时间： [math]T_1 = T_s + T_p[/math] 定义： [math]f = \frac{T_s}{T_1}[/math] 因此： [math]T_s = fT_1[/math] [math]T_p = (1 - f)T_1[/math] N 个处理器的运行时间： [math]T_N = fT_1 + \frac{(1 - f)T_1}{N}[/math] 加速比： [math] S(N) = \frac{T_1}{T_N} = \frac{1}{f + \frac{1 - f}{N}} [/math] 其中 f 是串行工作比例，[math] 1-f [/math] 是可并行工作。Amdahl 公式也可以写成： [math] S(N) = \frac{T_1}{T_N} = \frac{1}{(1-p) + \frac{p}{N}} [/math] 其中 [math] p=1-f [/math]，[math] f=1-p [/math]

2.3 当 N → ∞ 时的极限

[math]S(\infty) = \frac{1}{f}[/math] 如果串行比例为 10%（f = 0.1）： [math]S_\infty = 10[/math] 即使处理器无限，也无法超过该值。

2.4 Amdahl 定律的实际应用场景

Amdahl 适合优化固定任务的 延迟：

• GPU 内核优化固定张量大小
• 单次请求推理延迟降低
• 视频编码、压缩、排序
• 加速固定批量作业
• 数据库查询加速

---

3. Gustafson 定律（可扩展工作量）

3.1 直觉

Gustafson 反过来问： “增加处理器，我能在相同时间内解决多大的问题？” 这反映了真实 HPC 工作负载：更多 CPU → 更高分辨率 → 更大模拟。

3.2 推导

假设程序在 N 个处理器上运行 1 个时间单位。 设：

• f = 串行比例（按规模测量）

可并行部分随处理器数量扩展，因此其运行时间保持与 N 成比例。 一个处理器的时间： [math]T_1 = f + N(1 - f)[/math] 加速比： [math]S(N) = f + N(1 - f)[/math] Gustafson 公式的 “N 减” 形式： [math]S(N) = N - (N - 1)f[/math] 或者，如果定义并行比例 [math]p = 1 - f[/math]，公式也可写为： [math]S(N) = f + N(1-f) = f + Np [/math] “N 减” 形式用 p 表示： [math] S(N) = N-(N-1)f = N - (N-1)(1-p) [/math]

3.3 解释

随着 N 增加，加速比趋近于： [math]S(N) \approx N(1 - f)[/math] 对于小串行比例，几乎呈线性增长。

3.4 Gustafson 定律的实际应用场景

Gustafson 适用于 吞吐量扩展 或可增加问题规模的工作负载：

• 天气和气候模拟
• 粒子模拟、CFD、有限元分析
• LLM 训练：更多 GPU → 更长序列或更大模型
• 大数据分析（Spark, Dask, Flink）
• 蒙特卡洛模拟

---

4. Amdahl 定律 vs Gustafson 定律（比较表）

项目	Amdahl	Gustafson
工作负载	固定	随 N 扩展
目标	降低延迟	增加吞吐量
加速比上限	有界: [math]1/f[/math]	近似线性: [math]N(1-f)[/math]
悲观/乐观	悲观	乐观
应用场景	优化现有任务	扩展大规模工作量

---

5. 实际应用场景（综合视角）

Amdahl（延迟优化）

• 减少单次 LLM 查询推理时间
• 加速数据库 join 操作
• 固定张量 GPU 内核优化
• 视频编码（相同视频）

Gustafson（吞吐量 / 扩展）

• LLM 训练（扩展至更多 GPU）
• 高分辨率天气模型模拟
• 大数据 ETL 扩展
• 科学 HPC 工作负载

6. Python 绘图脚本（显示两条定律）

下面代码生成 Amdahl 与 Gustafson 加速比曲线图。 可以调整 f（串行比例）和处理器数量 N。 脚本绘制两条曲线在同一张图上。 包括部分 [math]f[/math] 的值，例如串行部分： import numpy as np import matplotlib.pyplot as plt def amdahl_speedup(N, s): return 1.0 / (s + (1 - s) / N) def gustafson_speedup(N, s): return s + (1 - s) * N # Number of processors N = np.arange(1, 65) # Serial fractions to consider Serial = [0.05, 0.1, 0.2, 0.3, 0.5, 0.8, 0.9, 1.0] plt.figure(figsize=(10, 6)) for f in Serial: plt.plot(N, amdahl_speedup(N, f), linestyle='-', label=f"Amdahl Serial={f}") plt.plot(N, gustafson_speedup(N, f), linestyle='--', label=f"Gustafson Serial={f}") plt.title("Amdahl's Law") plt.xlabel("Number of Processors (N)") plt.ylabel("Speedup") plt.legend() plt.grid(True) plt.tight_layout() plt.savefig("parallel-speedup-amdahl-vs-gustafson.png") ## plt.show() 下面是 Amdahl 与 Gustafson 曲线图示。 [caption id="attachment_70445" align="alignnone" width="1000"] Amdahl 定律加速曲线[/caption] [caption id="attachment_70446" align="alignnone" width="1000"] Amdahl vs Gustafson 加速曲线[/caption] [caption id="attachment_70447" align="alignnone" width="1000"] Gustafson 定律加速曲线[/caption]

图示解读

• Amdahl 曲线迅速趋于平缓——受串行部分限制。
• Gustafson 曲线几乎线性上升——适用于可扩展工作负载。
• 串行比例 f 越高，两种模型差距越大。

结论

Amdahl 定律展示了固定工作负载下的并行 上限，适合延迟优化。Gustafson 定律展示了随工作负载扩展的并行 潜力。

• Amdahl 定律 → 固定规模工作负载 → 收益递减
• Gustafson 定律 → 可扩展工作负载 → 近似线性加速
• 结合使用理解硬件极限与算法特性
• Python 工具使可视化直观易懂

它们共同构成现代并行系统性能分析基础，从 HPC 到 LLM 训练，再到 GPU 计算。 英文：The Truth About Parallel Speedup: Amdahl’s Limits vs Gustafson’s Scaling

性能隐藏的引擎：数据存放在哪里决定一切

1. 性能的真正秘密：数据放在哪里决定一切 2. 决定系统快慢的不是 CPU，而是数据的距离 3. 缓存才是现代计算性能的核心 4. 忽视数据局部性，一切性能优化都是徒劳 5. 性能瓶颈不在算力，而在内存层级 6. 数据局部性：被低估的性能决定因素 7. CPU 在等你的内存：缓存层级的真实代价 8. 系统速度快的真正原因：一切都与缓存有关 9. 别再关注 CPU 速度了——数据局部性才是制胜关键 10. 为什么缓存是所有高性能系统的幕后引擎 11. 性能的关键不在于 GHz，而在于距离 12. 你的 CPU 正在等待内存：缓存不为人知的故事 13. 数据局部性：计算机领域最重要却鲜为人知的因素 14. 数据存储位置决定一切 15. 缓存主宰一切：性能指南 16. 内存层次结构：性能的隐形杀手（或救星） 17. 为什么现代性能之战是与延迟的较量，而非与计算能力的较量

我们喜欢讨论 CPU 频率，但在实际系统中，关键问题是：你的数据存放在哪里？ 现代 CPU 依赖一个分层的内存体系（寄存器 → L1 → L2 → L3 → DRAM）。L1 访问可能只需约 4 个周期；而 DRAM 访问可能需要 200+ 个周期——那是 50× 更慢。如果你的工作集能放进缓存，一切飞快；如果不能，CPU 就会阻塞等待。

为什么缓存主导一切

分组处理是一个典型例子。每个数据包都会触发表查找。如果这些表能保持在缓存中，你可以每秒处理数百万个包；一旦溢出到 DRAM，吞吐量会崩塌。

真正的设计问题： 它能放进缓存吗？

[caption id="attachment_70404" align="alignnone" width="476"] CPU寄存器/缓存/架构[/caption] 缓存不仅仅关乎数据。指令缓存未命中也会毁掉尾延迟。有些高频交易系统会让热路径持续执行，只在需要发包时才打开网卡，从而保持 指令缓存持续命中。在交易环路中，一个 I-cache 停顿就可能占据全部延迟预算。

抽象失灵的地方

“全都上云”这类高层策略常忽略底层现实。虚拟化网络功能依赖于诸如：

• 独占核亲和（core pinning） —— 保持线程在同一 CPU 上以维持缓存热度
• 中断合并（interrupt coalescing） —— 降低中断率但以延迟为代价
• NUMA 局部性 —— 跨插槽访问会严重削弱性能
• 物理网卡与虚拟网卡 行为不同

销售演示会说“可以工作”，但细则通常是：需要 3 倍硬件、3 倍许可证，性能仍然无法与裸机匹配。 一旦你依赖缓存行为、核亲和和 NUMA 局部性，平台就不再可互换。

AI 也碰到同样的问题

即便在 AI 领域，物理规律也没变。模型越来越大，但数据移动依旧主导计算。局部性仍然是王道。

• 数组优于指针密集的结构，因为内存是连续的
• 硬件预取器只有在访问可预测时才有用
• 当内存布局合理时，缓存行被更高效地利用

在机器人控制中也能看到

在多轴运动控制中，第一个轴会“预热”缓存并承担缺失惩罚；后续轴的计算因为数据已经热化而耗时减半。相同的原理：局部性 = 速度。

IBM Telum：不同量级的缓存

IBM 的 Telum 处理器把这个想法推到了极端：

• 十个 36 MB 的 L2 缓存
• 360 MB 的虚拟 L3
• 2.8 GB 的虚拟 L4

[caption id="attachment_70405" align="alignnone" width="480"] IBM Telum 处理器[/caption] 该架构可以按需将 L2 转作 L3 使用。IBM 尚未公开这些缓存层的具体访问延迟，但在如此大规模的缓存下，大小、互连距离与命中延迟之间的折衷会非常有趣。

结论

性能归根结底由数据和指令能离核心多近来决定。 为局部性而设计，你的系统会表现出色。忽视它，再多的 GHz 或再多的云抽象也救不了你。

我们经常谈论 CPU 速度，却很少关注数据存储的位置。 性能主要取决于数据存储的便利程度。寄存器、L1 缓存、L2 缓存、L3 缓存、主内存——每一步都会增加延迟并降低吞吐量。访问主内存可能需要 200 个时钟周期，比 L1 缓存慢 50 倍。 当工作集能够放入缓存时，代码运行速度极快。否则，CPU 只能等待。 在数据包处理中，这种差异决定了一切。每个数据包都会触发表查找。如果这些表保存在 缓存 中，您可以每秒处理数百万个数据包。否则，吞吐量将急剧下降。 所以，下次设计数据结构时，请问问自己： 它能放进缓存吗？ 因为在对性能要求极高的系统中，缓存不仅仅是一种优化手段，它定义了整个系统。 而且不仅是数据，指令也一样！我见过高频交易工程师讨论他们的策略，他们将热路径编程为始终处于激活状态，并且只在数据包需要离开系统时才启用网卡。这样也能保持指令缓存处于热状态。 保持指令缓存处于热状态与保持数据缓存处于热状态同样重要，尤其是在对可预测性要求很高的工作负载中。优化热路径，使 CPU 始终保持在指令缓存中至关重要，因为即使是很小的停顿也可能导致尾延迟显著增加。这很好地提醒我们，架构设计的真正目的是尽可能地将指令和数据都放在靠近核心的位置。 很多技术决策者都固守一刀切的策略：例如……万物皆可云——他们认为任何虚拟化工作负载都可以在任何虚拟化环境中运行，底层硬件和虚拟化技术都只是商品而已。但这并不适用于虚拟化网络功能，因为厂商们早就知道，独占线程核心绑定可以让执行线程独占使用 CPU 缓存。厂商们也知道，在虚拟化环境中，中断合并可以降低“CPU 使用率”，但会增加延迟。他们了解 NUMA 局部性，甚至把这些都写进了文档里。当然，销售人员来了之后，他们希望与高层战略保持一致，使用最佳优化基准测试，然后就云或虚拟机管理程序支持的问题展开另一场不加任何细节的讨论。没错，这行得通*但附注：你需要三倍的许可证/硬件，而且仍然无法获得最佳性能。人们对底层性能如此缺乏兴趣，技能差距如此之大，以至于似乎只能通过增加抽象层和厂商来掩盖责任。如果珠穆朗玛峰是检验技术领导力还是厂商责任的试金石，那么我们很想知道，究竟是哪一方会坚持到底，还是会在山脚下卖羽绒服。完全正确。一旦你依赖缓存行为、核心绑定和NUMA局部性，平台就不再具有可互换性了。底层细节远比大多数高层策略重要得多。 大多数繁重的AI工作负载仍然会遇到相同的内存层次结构限制。模型规模不断扩大，但芯片内部数据传输的物理机制并没有发生太大变化。理解局部性仍然是获得良好性能的关键。 数组能够为CPU提供它真正需要的东西：连续的内存和可预测的访问模式。这意味着预取器可以真正发挥作用，缓存行可以得到高效利用，并且避免了分散结构带来的指针追踪惩罚。这是保持缓存友好性的最简单方法之一。 机器人多轴运动控制也是如此。第一个轴预热缓存并承受缓存未命中的影响，下一个轴的计算时间缩短了一半。 IBM Telum处理器可以验证这一点，它能够按需将L2缓存转换为L3缓存，并且L4缓存可以被任何其他CPU访问。此外，该芯片的时钟频率始终保持在 5.5 GHz。它包含十个 36 MB 的二级缓存¹，以及扩展的虚拟三级缓存（360 MB）和四级缓存（2.8 GB）。 这是一款令人着迷的芯片。与大多数架构相比，其缓存容量巨大，这让我不禁好奇这会对各级缓存的访问延迟产生怎样的影响。可惜的是，我找不到任何关于 Telum 缓存的公开延迟数据，否则我很想了解 IBM 在实际应用中是如何平衡缓存容量、交换空间距离和命中延迟的。

英文：The Hidden Engine of Performance: It’s All About Where the Data Lives (Cache is the King)

[caption id="attachment_70386" align="alignnone" width="2017"] Q Learning强化学习算法(机器学习/人工智能)[/caption] 强化学习（Reinforcement Learning, RL）是一种让智能体/Agent通过与环境交互、试错学习来获得最优行为策略的机器学习方法。本文用一个简单的 Q-learning 迷宫示例，帮助你快速理解强化学习的基本原理。

强化学习入门：从试错中学习的艺术 Reinforcement Learning 101: The Art of Learning by Trial and Error 深度解析强化学习：Q-Learning算法详解 Deep Dive into Reinforcement Learning: Understanding the Q-Learning Algorithm 机器如何学会自己做决定？强化学习告诉你答案 How Do Machines Learn to Make Their Own Decisions? Reinforcement Learning Explained 从奖励中学习：人工智能的“试错智慧” Learning from Rewards: The Trial-and-Error Intelligence Behind AI

一、什么是强化学习？

强化学习的世界中包含五个关键要素：

• Agent（智能体）：做决策、执行动作的主体
• Environment（环境）：智能体所处的世界
• State（状态）：当前环境的描述
• Action（动作）：智能体可采取的操作
• Reward（奖励）：环境反馈，用来衡量动作的好坏

智能体的目标是学习一个策略 π(a|s)，让它在每个状态下选择最优动作，从而获得最大的累积奖励。 [math]J(\pi) = \mathbb{E}\pi \left[ \sum{t=0}^{\infty} \gamma^t r_t \right][/math] 其中 [math]\gamma[/math]（0 ≤ [math]\gamma[/math] ≤ 1）是折扣因子，用于衡量未来奖励相对于即时奖励的重要程度。

二、Q-Learning 原理

Q-learning 是最经典的强化学习算法之一。它通过学习一个 Q 表（Q-table）来记录每个“状态-动作”对的价值。 更新公式如下： [math] Q(s,a) \leftarrow Q(s,a) + \alpha [r + \gamma \max_{a'} Q(s', a') - Q(s,a)] [/math] 其中：

• [math] \alpha [/math]：学习率（Learning Rate）
• [math] \gamma [/math]：折扣因子（Discount Factor）
• [math] r [/math]：奖励（Reward）
• [math] s' [/math]：下一状态（Next State）

三、迷宫环境设计

定义一个 3×5 的迷宫：

• 0：空地
• -1：墙
• 1：出口（目标）

四、完整 Python 实现代码

import numpy as np
import random

# 1️⃣ 定义迷宫
maze = np.array([
    [0,  0,  0, -1,  1],
    [0, -1,  0, -1,  0],
    [0,  0,  0,  0,  0]
])

n_rows, n_cols = maze.shape
actions = ['up', 'down', 'left', 'right']
Q = np.zeros((n_rows, n_cols, len(actions)))

# 2️⃣ 超参数
alpha = 0.1
gamma = 0.9
epsilon = 0.1
episodes = 500

# 3️⃣ 辅助函数
def is_valid(state):
    r, c = state
    return 0 <= r < n_rows and 0 <= c < n_cols and maze[r, c] != -1

def next_state(state, action):
    r, c = state
    if action == 'up': r -= 1
    elif action == 'down': r += 1
    elif action == 'left': c -= 1
    elif action == 'right': c += 1
    return (r, c)

def get_reward(state):
    r, c = state
    if maze[r, c] == 1: return 10
    elif maze[r, c] == -1: return -1
    return -0.1

# 4️⃣ 训练循环
for episode in range(episodes):
    state = (2, 0)
    done = False

    while not done:
        if random.uniform(0, 1) < epsilon:
            action_idx = random.randint(0, len(actions)-1)
        else:
            action_idx = np.argmax(Q[state[0], state[1]])

        action = actions[action_idx]
        next_s = next_state(state, action)

        if not is_valid(next_s):
            reward = -1
            next_s = state
        else:
            reward = get_reward(next_s)

        Q[state[0], state[1], action_idx] += alpha * (
            reward + gamma * np.max(Q[next_s[0], next_s[1]]) - Q[state[0], state[1], action_idx]
        )

        state = next_s
        if maze[state[0], state[1]] == 1:
            done = True

print("✅ 训练完成！")

# 5️⃣ 查看学到的路径
state = (2, 0)
path = [state]

while maze[state[0], state[1]] != 1:
    action_idx = np.argmax(Q[state[0], state[1]])
    next_s = next_state(state, actions[action_idx])
    if not is_valid(next_s) or next_s in path:
        break
    state = next_s
    path.append(state)

print("🗺️ 学到的路径:", path)

五、运行结果

运行上面的代码后，你会看到类似输出： ✅ 训练完成！ 🗺️ 学到的路径: [(2, 0), (2, 1), (2, 2), (1, 2), (0, 2), (0, 3), (0, 4)] 这说明智能体成功学会了走出迷宫 🎯

六、总结

强化学习使机器能够通过反馈学习最优策略，这类似于人类通过经验学习的方式。 Q-Learning 是许多现代强化学习算法的基础，包括深度 Q 网络（Deep Q-Networks, DQN）。 这个简单的示例展示了完整的强化学习循环：探索 → 反馈 → 改进。

• Q 表：保存每个状态-动作的价值
• ε-greedy 策略：平衡探索与利用
• 奖励函数设计：引导智能体形成目标导向行为
• 强化学习思想：通过试错和奖励反馈不断改进策略

强化学习的魅力在于，它不需要显式答案，而是让机器自己“摸索”出最优策略。你可以在此基础上继续扩展，比如加入 matplotlib 动画可视化 或使用 神经网络（Deep Q-Learning） 解决更复杂的任务。 英文：How Do Machines Learn to Make Their Own Decisions? Reinforcement Learning Explained

C++ 一直在不断增加新特性，以便程序员能够区分在编译时运行的代码和在运行时执行的代码。其中两个重要工具是函数 std::is_constant_evaluated()（C++20）和语言级别的 if consteval（C++23）。本文将解释这两者，展示实际示例，比较它们的保证和权衡，并建议在何时使用各自的方法。 这两种技术都允许你编写分支，根据当前的求值是在常量求值（编译时）上下文中还是运行时上下文中而表现不同。差异虽然细微，但非常重要：一个是返回布尔值的函数，另一个是编译器视为仅在编译时检查的特殊 if 语句，编译器会进行特殊处理。

std::is_constant_evaluated() (C++20)

这是一个在 <type_traits> 中声明的函数：

#include <type_traits>
constexpr bool std::is_constant_evaluated() noexcept;

当当前表达式在常量表达式（编译时）上下文中求值时，该函数返回 true，否则返回 false。 示例：

#include <iostream>
#include <type_traits>

constexpr int f() {
    if (std::is_constant_evaluated()) {
        return 42; // 编译时
    } else {
        return 0; // 运行时 
    }
}

int main() {
constexpr int a = f(); // 编译时求值 -> 42
    int b = f(); // 运行时求值 -> 0
    std::cout << a << ", " << b << "\n"; // 打印 "42, 0"
}

if consteval (C++23)

if consteval 是一个语言级别的 if 条件语句，编译器用它来判断当前求值上下文是否为常量求值。它提供了更强的编译时保证：编译器知道 consteval 分支在常量求值中必须可用，并且会拒绝不能在该上下文中出现的代码。 语法：

if consteval {
    // 仅编译时代码
} else {
    // 仅运行时代码
}

示例：

#include <iostream>

constexpr int f() {
    if consteval {
        return 42; // 编译时版本
    } else {
        return 0; // 运行时版本
    }
}

int main() {
    constexpr int a = f(); // 编译时上下文 -> 返回 42
    int b = f(); // 运行时上下文 -> 返回 0
    std::cout << a << ", " << b << "\n"; // 打印 "42, 0"
}

主要区别（总结）

• 形式： std::is_constant_evaluated() 是一个函数；if consteval 是一个语言级条件语句。
• 标准： std::is_constant_evaluated() 出现在 C++20 中；if consteval 出现在 C++23 中。
• 保证： if consteval 为编译器提供编译时保证，并拒绝编译时无法使用的 consteval 分支中的代码。 std::is_constant_evaluated() 的执行环境更为宽松：它返回布尔值，但不会强制编译器拒绝其他分支中无效的编译时构造。
• 在表达式内部使用： std::is_constant_evaluated() 可以在语句形式的 if 无法使用的表达式内部使用（例如，在三元运算符内部）。if consteval 需要语句级上下文。

具体比较示例

两个函数看起来相似，但在执行方面表现不同：

// if-consteval 示例
constexpr int f() {
    if consteval {
        return 1; // 仅在编译时
    } else {
        return 2; // 仅限运行时
    }
}

// std::is_constant_evaluated() 示例
#include <type_traits>
constexpr int g() {
    if (std::is_constant_evaluated()) {
        return 1; // 可能仍会编译运行时路径
    } else {
    return 2;
    }
}

以下场景中，差异至关重要：

// 使用 if consteval 时，编译器将拒绝无效的仅限编译时构造
constexpr int bad() {
    if consteval {
        std::cout << "compile-time"; // ❌ 错误 — 常量求值中不允许 I/O
    }
    return 0;
}

// 使用 std::is_constant_evaluated() 时，编译器会更加宽容，可能会编译通过，直到代码
// 实际用于常量表达式上下文。
#include <type_traits>
constexpr int perhaps_bad() {
    if (std::is_constant_evaluated()) {
        std::cout << "compile-time"; // 可能会编译通过；只有在 const-expr 中求值时才会出现错误
    }
    return 0;
}

使用场景

• 如果您的目标是 C++23（或更高版本），并且想要清晰的、编译时强制的分支：请优先使用 if consteval。
• 如果您必须仅支持 C++20 环境：请使用 std::is_constant_evaluated()。
• 如果您需要在表达式（而非语句）中进行检查，请使用 std::is_constant_evaluated()，因为 if consteval 是语句级的。
• 如果您希望编译器拒绝编译时无法使用的代码，if consteval 可以提供更强的保证。

实际用例

• 为编译时和运行时（快速预计算 vs 较慢的运行时）编写不同的实现逻辑）。
• 保护仅运行时操作（例如 I/O、动态分配或系统调用），以免它们被意外地用于常量求值路径。
• 在编写可在 constexpr 上下文和正常运行时上下文中使用的库时，提供更清晰、更能揭示意图的代码。

简短实用的检查清单

• 需要表达式级检查？→ std::is_constant_evaluated()。
• 想要编译器强制执行的仅编译时分支？→ if consteval。
• 仅针对 C++20？→ std::is_constant_evaluated()。
• 针对 C++23+ 并更注重清晰度和安全性？ → if consteval.

TL;DR

std::is_constant_evaluated() — C++20：在编译时求值中返回 true 的函数（适用于表达式级检查）。 if consteval — C++23：

• 编译器将其视为仅编译时分支的语言级条件语句；
• 更强的编译时执行力和更清晰的意图。

结束语

这两个工具都很有用。如果您可以使用 C++23，则最好使用 if consteval 以获得更清晰的语义和更强的编译时保证，并在与 C++20 兼容或需要表达式级检查时回退到 std::is_constant_evaluated() [show_file file="/var/www/wp-post-common/justyy.com/cpp.php"] 英文：Detecting Compile-time vs Runtime in C++: if consteval vs std::is_constant_evaluated()

“用树莓派打造家庭 2TB 网络硬盘” “树莓派 + WD 硬盘：轻松为孩子的 Mac 提供共享存储” “家庭文件共享不再难：自制树莓派网络硬盘” “让树莓派变身 2TB 家庭共享硬盘” “为孩子的 Mac 节省空间：树莓派网络硬盘实战”

前两年，我给两个孩子各买了一台 MacBook Pro。弟弟的那台当时大概六百多买的，SSD 只有 256GB，所以经常硬盘爆满，只能不断删除下载的文件、dmg 安装包之类的。用了一段时间后，MBP 的 ~/Caches 目录也会变得很大，虽然可以临时清理，但这只是治标不治本。 我就跟孩子说，你可以把一些文件放到云盘上，比如 OneDrive、Google Drive，或者我给你接个 USB 硬盘挂到电脑上。OneDrive 有“本地不占空间、数据存到云端”的模式，很省地方，但免费空间只有 5GB。Google Drive 免费空间是 15GB，可用于邮件、照片和 Drive 共享。 孩子不太喜欢用 USB 硬盘，一方面得接电源，另一方面得用 Type-C 转 USB 接口，很麻烦，也不想总插着。 我想到家里有树莓派，可以接一个移动硬盘，通过文件共享，把家里几台电脑都挂接成网络硬盘（Map Network Drive）。于是，我找了几个抽屉，找到一个 2TB 的西部数据（WD）硬盘，3.5 寸的，需要外接硬盘盒，正好前几个月折腾数据时买了一个。 之前挂在HPZ800服务器的D盘。 [caption id="attachment_70022" align="alignnone" width="753"] 这个硬盘用了两年多，当时应该是HPZ800服务器的D盘（可以接四个硬盘）[/caption]

添加网络硬盘：树莓派通过SAMBA挂接移动硬盘

为了确保硬盘没坏道，我用 CrystalDiskInfo 检查了一下，还让 ChatGPT 帮我看了健康状态——2.3 年通电时间，没有坏道，一切正常。 [caption id="attachment_70028" align="alignnone" width="671"] 2TB的西数硬盘还可以再战几年！[/caption]

准备挂接硬盘

第一步，把硬盘接到树莓派上，直接用 USB，但需要额外电源。我找了一个插座，勉强可以在鞋柜里塞下两个插头：一个 3.5 寸硬盘盒和树莓派 4B。 [caption id="attachment_70021" align="alignnone" width="543"] 先用df命令看看USB有没有被系统认到。[/caption] 然后 SSH 登录树莓派，发现硬盘是 NTFS 格式，需要挂载一下：

mkdir /mnt/usb
mount -t ntfs-3g /dev/sdb1 /mnt/usb

其中 /mnt/usb 是挂载目标目录，需要先创建。 如果想开机自动挂载，只需在 /etc/fstab 添加一行：

UUID=<ID> /mnt/usb ntfs-3g defaults,uid=1000,gid=1000,umask=0000,nofail,x-systemd.device-timeout=10 0 0

<ID> 是硬盘的 UUID，可以通过 lsblk -f 查到。

SAMBA网络硬盘

文件共享最简单的方法是安装 Samba：

sudo apt install -y samba

安装完成后，编辑 /etc/samba/smb.conf 添加以下内容：

[usb2share]
   path = /mnt/usb
   browseable = yes
   writable = yes
   guest ok = no
   create mask = 0777
   directory mask = 0777
   valid users = pi

valid users 可以写多个用户，用空格分隔，也可以用 @ 表示群组。用户必须是 Linux 本身存在的账号。 设置 SMB 密码：

sudo smbpasswd -a pi

重启服务：

sudo systemctl restart smbd

添加网络硬盘

在 Windows 上，可以在“此电脑”里右键“添加网络驱动器”，输入地址：

\\192.168.IP地址\usb2share

输入用户名和密码，勾选“记住密码”即可添加网络硬盘，用起来跟本地硬盘差不多。 在 Mac 上，可以在 Finder 按 Command + K 添加服务器，同样输入 树莓派的IP地址、用户名和密码即可。 我给两个孩子和老婆各建了一个目录，让他们把数据放到自己的目录下，2TB 够用一段时间了。 有了这个网络硬盘，分享数据也方便多了（电影、照片等），再也不用通过 WeChat、Whatsapp 或 Google Drive 分享——这些方式要么不方便查找历史文件，要么照片会被压缩。 真好，一下子又让树莓派多了一个用途，不再是积灰的机器了。 [caption id="attachment_70020" align="alignnone" width="864"] 目测还有空间，还可以再加一个树莓派/硬盘等。[/caption] [caption id="attachment_70027" align="alignnone" width="2048"] 把硬盘塞到门口的鞋柜里，电线好乱，还好门一关，媳妇看不见。[/caption] [caption id="attachment_70026" align="alignnone" width="456"] 第一次连接需要用户名/密码[/caption] [caption id="attachment_70025" align="alignnone" width="1028"] 网络硬盘成功的成了本地资源的一部分。[/caption] [caption id="attachment_70024" align="alignnone" width="377"] 可以像本地硬盘一下查看属性：使用空间/剩余空间等。[/caption] [caption id="attachment_70023" align="alignnone" width="628"] 输入IP地址即可访问网络硬盘。选择要挂接的盘符。一般网络硬盘都是从Z往前用。[/caption] 英文：Found a 2TB Old Hard Drive - Still Young and Healthy [show_file file="/var/www/wp-post-common/justyy.com/raspberrypi.php"]