Forem: Jian Wang

PyMOL 画小分子的静电势 (ESP)

Jian Wang — Fri, 19 Dec 2025 22:33:30 +0000

本文档记录了从原始 .mol2 文件出发，通过密度泛函理论 (DFT) 计算并生成用于 PyMOL 绘图的 ESP Cube 文件的完整步骤。

1. 分子预处理

为了保证量子化学计算的准确性，必须确保分子的原子价态和氢原子完整。

工具: Open Babel
操作: 将 .mol2 转换为 .xyz 格式，并根据需要补全氢原子（补氢对 ESP 计算至关重要）。

命令:

# 补氢并转换为 xyz
obabel input.mol2 -h -oxyz -O molecule.xyz

2. ORCA 计算配置

使用 ORCA 6.1.1 运行单点能计算，并保存电子密度信息以备后处理。

输入文件 (molecule.inp) 核心部分:
```
! B3LYP def2-SVP TightSCF KeepDens PAL8
* xyz 0 1
[原子坐标]
*
```
- KeepDens: 关键参数，告诉 ORCA 保留电子密度文件（.scfp），否则后处理无法生成 ESP。
- PAL8: 使用 8 核并行。在集群 SLURM 环境下，建议配合 --ntasks-per-node=8 使用。

3. 生成 Cube 文件 (后处理)

ORCA 6.1.1 使用 orca_plot 交互工具从计算结果 (.gbw) 中提取 ESP。

工具: orca_plot
交互序列 (可通过重定向执行):
1. 输入 1 (选择绘图类型)
2. 输入 43 (选择 Electrostatic Potential)
3. 输入 4 (设置网格间距/分辨率，建议输入 100 100 100)
4. 输入 11 (执行生成任务)
5. 输入 12 (退出)
产物:
- molecule.eldens.cube: 电子密度文件（定义分子形状）。
- molecule.vpot.cube (或重命名为 _ESP.cube): 静电势数值文件。

4. PyMOL 可视化命令

在 PyMOL 中将 ESP 数值映射到分子表面。

# 1. 载入所有文件
load molecule.mol2, mol
load molecule.eldens.cube, den
load molecule_ESP.cube, esp

# 2. 生成基于电子密度的分子表面 (等值面取 0.002 a.u.)
isosurface surf, den, 0.002

# 3. 创建颜色映射渐变 (单位为原子单位 a.u.)
# [-0.1, 0, 0.1] 对应红-白-蓝映射
# 负电位 (红色) = 富电子区; 正电位 (蓝色) = 欠电子区
ramp_new ramp_esp, esp, [-0.1, 0, 0.1], [red, white, blue]

# 4. 将颜色映射到表面
set surface_color, ramp_esp, surf

# 5. 美化调整
set surface_quality, 1
set transparency, 0.2, surf  # 可选：设置表面半透明以观察内部原子
rebuild

注意事项

单位: ORCA 输出的 ESP 单位为 a.u. (1 a.u. ≈ 27.21 V)。PyMOL 中的刻度应根据分子极性适当调整（常用范围 $\pm 0.05$ 到 $\pm 0.2$）。
文件保持: 确保 .gbw 和 .scfp 文件在同一目录下，orca_plot 才能正常运行。
并行槽位: 在使用 MPI 并行时，确保 SLURM 分配的 ntasks 与 ORCA PALn 关键字一致。

pytorch register_buffer的一些思考

Jian Wang — Wed, 24 Sep 2025 15:53:08 +0000

在 PyTorch 中，当我们需要在模型中存储一些不需要梯度的张量时，经常会遇到这样的选择：

# 方案1：直接赋值
self.position_encoding = position_encoding

# 方案2：使用 register_buffer
self.register_buffer("position_encoding", position_encoding)

很多人可能会问：既然都可以存储张量，为什么还要用 register_buffer？

直接赋值的潜在问题

1. 设备不匹配问题

最直接的问题就是设备管理。当你将模型移动到 GPU 时：

# 使用直接赋值
self.position_encoding = position_encoding  # 在CPU上

model = model.cuda()  # 模型参数移动到GPU
# 但是 position_encoding 仍然在CPU上！

# 在forward中使用时会出现设备不匹配错误
result = some_operation(self.position_encoding, gpu_tensor)  # 错误！

2. 梯度计算混乱

PyTorch 可能会误认为这些张量是需要梯度的参数，在反向传播时尝试计算梯度，浪费计算资源。

register_buffer 的优势

1. 自动设备管理

self.register_buffer("position_encoding", position_encoding)

model = model.cuda()  # 缓冲区自动移动到GPU
model = model.cpu()   # 缓冲区自动移动回CPU

2. 明确的模型结构

# 查看模型的所有缓冲区
list(model.buffers())
model.named_buffers()

# 区分参数和缓冲区
list(model.parameters())  # 需要梯度的参数
list(model.buffers())     # 不需要梯度的张量

实际案例：位置编码模型

让我们看一个具体的例子。假设我们有一个需要位置编码的模型：

class PositionalEncodingModel(nn.Module):
    def __init__(self, vocab_size, d_model, max_seq_len):
        super().__init__()

        # 计算位置编码矩阵
        position_encoding = torch.zeros(max_seq_len, d_model)
        position = torch.arange(0, max_seq_len).unsqueeze(1)

        div_term = torch.exp(torch.arange(0, d_model, 2) * 
                           -(math.log(10000.0) / d_model))

        position_encoding[:, 0::2] = torch.sin(position * div_term)
        position_encoding[:, 1::2] = torch.cos(position * div_term)

        # 注册为缓冲区
        self.register_buffer("position_encoding", position_encoding)

        # 可训练参数
        self.embedding = nn.Embedding(vocab_size, d_model)
        self.transformer = nn.Transformer(d_model)

    def forward(self, input_ids):
        seq_len = input_ids.size(1)

        # 位置编码自动在正确的设备上
        pos_embeddings = self.position_encoding[:seq_len, :]

        # 词嵌入 + 位置编码
        embeddings = self.embedding(input_ids) + pos_embeddings

        return self.transformer(embeddings)

这些位置编码是预计算的固定值，它们：

不需要梯度（固定的数学变换）
需要与模型一起保存和加载
需要与模型参数在同一设备上

使用场景

# 模型在GPU上运行
model = model.cuda()
input_ids = input_ids.cuda()

# 位置编码自动在GPU上，不会出现设备不匹配错误
output = model(input_ids)  # 正常工作

关于重新计算的思考

有人可能会问：既然 register_buffer 保存了张量，为什么在 __init__ 中还要计算一遍？

def __init__(self, ...):
    # 1. 计算一遍
    position_encoding = compute_position_encoding()

    # 2. 注册缓冲区
    self.register_buffer("position_encoding", position_encoding)

# 加载时：
model.load_state_dict(torch.load('model.pth'))  # 3. 又从state_dict恢复

这确实看起来有重复计算，但实际上：

计算成本较低：这些矩阵计算很快
代码简洁性：避免复杂的延迟加载逻辑
数值一致性：保存的是训练时的精确值，避免浮点数精度差异
设备管理：确保缓冲区与模型在同一设备上

如果确实想优化，可以这样做：

def __init__(self, ..., compute_encoding=True):
    if compute_encoding:
        # 正常计算
        position_encoding = compute_position_encoding()
        self.register_buffer("position_encoding", position_encoding)
    else:
        # 延迟计算
        self.register_buffer("position_encoding", None)

随机数一致性

register_buffer 还有一个重要优势：随机数一致性。

# 如果缓冲区包含随机初始化的张量
random_buffer = torch.randn(10, 10)
self.register_buffer("random_buffer", random_buffer)

# 每次加载模型时，随机数是完全一致的
# 这确保了模型行为的可重现性

最佳实践

何时使用 register_buffer：
- 存储不需要梯度的张量
- 需要与模型一起保存/加载的张量
- 需要自动设备管理的张量
何时直接赋值：
- 临时计算结果的存储
- 不需要保存的中间变量
- 纯 Python 对象（非张量）
命名规范：

   # 好的命名
   self.register_buffer("position_embeddings", pos_emb)
   self.register_buffer("attention_mask", mask)

   # 避免的命名
   self.register_buffer("temp", temp_tensor)

总结

register_buffer 不仅仅是简单的属性赋值，它提供了：

自动设备管理：确保张量与模型在同一设备上
状态持久化：自动保存和加载
结构完整性：明确的模型状态管理
数值一致性：保存精确的计算值

虽然在某些情况下看起来有重复计算，但考虑到代码简洁性和可靠性，这种设计是合理的。在 PyTorch 开发中，正确使用 register_buffer 是写出健壮模型的重要技能。

服务器 tmux 持久化问题

Jian Wang — Sat, 20 Sep 2025 14:14:33 +0000

之前我都是通过 ssh 连接到学校的 HPC 上，然后运行 tmux
这样断开 ssh 之后 tmux 也还是会运行，方便我下次连接 ssh 的时候继续上次的工作
今天我发现断开 ssh 之后 tmux 也断了
可能是 ssh 断开之后服务器会自动杀死在 ssh 运行期间的后台任务
经过查询 chatgpt 找到如下解决方案
创建一个新的文件：~/.config/systemd/user/tmux@.service
输入如下内容：

[Unit]
Description=Tmux session %i
After=default.target

[Service]
Type=forking
ExecStart=/usr/bin/tmux new-session -d -s %i
ExecStop=/usr/bin/tmux kill-session -t %i
Restart=always
WorkingDirectory=%h

[Install]
WantedBy=default.target

然后输入如下命令：

systemctl --user enable tmux@main
systemctl --user start tmux@main

这样每次登录之后只需要运行 tmux attach -t main就可以连接到 tmux 了