[!warning]

1. 本文档相关配置以最新版 CPA 和 CPAMP 为准。
2. NGINX 默认部署在宿主机。

Docker 统一部署

services:
  cli-proxy-api:
    image: eceasy/cli-proxy-api:latest
    container_name: cli-proxy-api
    ports:
      - "127.0.0.1:8317:8317"
    volumes:
      # CPA 配置文件
      - ./config.yaml:/CLIProxyAPI/config.yaml
      # 凭证目录
      - ./auth-dir:/root/.cli-proxy-api
      # 插件
      - ./plugins:/CLIProxyAPI/plugins
    restart: unless-stopped

  cpa-manager-plus:
    image: seakee/cpa-manager-plus:latest
    restart: unless-stopped
    ports:
      - '127.0.0.1:18317:18317'
    volumes:
      - ./cpa-manager-plus-data:/data
    depends_on:
      - cli-proxy-api

上述 docker compose 文件中，映射端口全部指定了 host 为 127.0.0.1，防止通过 公网IP:Port 访问到相关服务。

NGINX 反向代理

[!note] 该部分参考反向代理 | CPA Manager Plus

首先，在 NGINX 的 http 块中加入如下配置，以支持正确处理 WebSocket 等需要 HTTP 协议升级（Upgrade）的反向代理请求：

# 其他配置
...

http {
    # 其他配置
    ...
    
    # 添加如下部分
    map $http_upgrade $connection_upgrade {
            default upgrade;
            ''      close;
    }
}

然后，在 NGINX 配置文件目录 conf.d 下新增 cpa.conf：

# 指定后端别名
upstream cpa_api {
    server 127.0.0.1:8317;
}

upstream cpamp {
    server 127.0.0.1:18317;
}

# http 默认跳转
server {
    listen 80;
    server_name your.cpa.domain;

    return 301 https://$host$request_uri;
}

server {
    listen 443 ssl;
    server_name your.cpa.domain;
    http2 on;
	
	# SSL 证书配置
    ssl_certificate xxx;
    ssl_certificate_key xxx;

    ssl_protocols TLSv1.2 TLSv1.3;

    client_max_body_size 64m;

    proxy_http_version 1.1;
    proxy_read_timeout 3600s;
    proxy_send_timeout 3600s;
    proxy_buffering off;

    proxy_set_header Host              $host;
    proxy_set_header X-Real-IP         $remote_addr;
    proxy_set_header X-Forwarded-For   $proxy_add_x_forwarded_for;
    proxy_set_header X-Forwarded-Proto $scheme;
    proxy_set_header Upgrade           $http_upgrade;
    proxy_set_header Connection        $connection_upgrade;

    # 默认进入 CPAMP 面板
    location = / {
        return 302 /management.html;
    }

    # ===== CPA Manager Plus =====

    location = /management.html { proxy_pass http://cpamp; }
    location = /health          { proxy_pass http://cpamp; }
    location = /status          { proxy_pass http://cpamp; }
    location = /setup           { proxy_pass http://cpamp; }

    # CPAMP 兼容接口与运行时接口
    location ^~ /usage-service/ { proxy_pass http://cpamp; }

    # /v0/management/* 先进入 CPAMP：
    # - 用量 / 模型价格 / API 密钥别名 / 仪表盘 / 请求监控 /
    #   Codex 账号巡检 / 导入导出 等由 CPAMP 自己处理
    # - 其他 CPA 管理接口由 CPAMP 使用服务端保存的 CPA Management Key 继续代理到 CPA
    #
    # 注意：不要只配置 location = /v0/management
    # 应使用带尾斜杠的前缀匹配 /v0/management/
    location ^~ /v0/management/ { proxy_pass http://cpamp; }

    # CPAMP 插件页面资源。缺少此规则时，插件页面可能打开空白或资源 404。
    location ^~ /v0/resource/plugins/ { proxy_pass http://cpamp; }

    # /models 由 CPAMP 提供兼容代理
    # 如果 CPAMP 尚未完成 setup，访问此路径可能返回 412
    location = /models          { proxy_pass http://cpamp; }

    # ===== CPA / CLI Proxy API =====

    # OpenAI / Claude Code / Codex 等实际 API 请求应直接走 CPA
    location ^~ /v1/                 { proxy_pass http://cpa_api; }
    location ^~ /v1beta/             { proxy_pass http://cpa_api; }
    location ^~ /backend-api/codex/  { proxy_pass http://cpa_api; }
    location ^~ /api/                { proxy_pass http://cpa_api; }

    # CPA 特殊路由与 OAuth 回调
    location = /v1internal:method    { proxy_pass http://cpa_api; }
    location = /healthz              { proxy_pass http://cpa_api; }
    location = /anthropic/callback   { proxy_pass http://cpa_api; }
    location = /codex/callback       { proxy_pass http://cpa_api; }
    location = /google/callback      { proxy_pass http://cpa_api; }
    location = /antigravity/callback { proxy_pass http://cpa_api; }

    # 兜底给 CPA
    # 用于 CPA 根路径、Amp 路由以及未来新增接口
    location / {
        proxy_pass http://cpa_api;
    }
}

上述配置完成后，无需在防火墙开放 8317/18317 端口，保持关闭即可。

配置连接信息

首次启动后，在 docker logs <container_id> 中可以看到 camp_xxx 字样的密钥，复制保存。该密钥为登录 CPAMP 面板的密钥。CPA 的密钥根据面板提示逐步设置。如果已经存在正在使用的 CPA，会自动接入对应信息。

需注意，CPA 地址在本文档的部署情况下，即 CPA 和 CPAMP 部署于同一 Docker 网络下，请填写 NGINX 中配置的后端名称：http://cli-proxy-api:8317

[!note] "人是为活着本身而活着的，而不是为了活着之外的任何事物所活着。"

余华在《活着》的韩文版自序中写下了这句话。它不是小说正文中的台词，而是余华对整部作品精神内核的提炼。

为什么这样说？

福贵的一生，是"剥去"的过程。小说中的福贵，本是地主家的少爷，年轻时挥霍无度。此后，他的人生就像被命运一层层地"剥皮"——家产败光、父亲气死、母亲病逝、儿子有庆被抽血致死、女儿凤霞难产而亡、妻子家珍病故、女婿二喜工地事故、外孙苦根吃豆子撑死……所有"活着之外"的东西——财富、地位、亲情、希望——都被一一夺走。

到最后，福贵只剩一头也叫"福贵"的老牛相伴。然而他并没有崩溃，没有自杀，没有怨天尤人，而是平静地牵着老牛在田间劳作，平静地给路人讲述自己的一生。

《活着》用这种极致的"剥夺"告诉我们：当所有外在的支撑都被拿走之后，福贵依然在活着。 这说明，活着本身不需要任何外在的理由和附加的意义。

对"意义焦虑"的反叛

我们习惯为活着寻找理由——为了理想、为了爱情、为了家人、为了成就。这些当然美好，但余华提出了一个尖锐的问题：如果这些理由全部消失了呢？你还活不活？

福贵的回答是：活。不是因为勇敢，不是因为坚强，而是因为活着本身就是生命最本能的状态。余华借此打破了我们对"痛苦使人崇高"的浪漫想象——苦难就是苦难，它不带来升华，不带来顿悟，福贵的忍受是沉默的、朴素的、近乎植物般的韧性。

余华曾说："活着的力量不是来自于呐喊，也不是来自于进攻，而是忍受。" 福贵的活着，不是英雄式的抗争，而是一种中国人特有的、与土地相连的生存哲学——像庄稼一样，接受风雨，接受命运，默默扎根，静静生长。这种"忍受"的中国式生存智慧不是懦弱，而是一种对生命本身最深沉的尊重。这句话初读似乎有些"虚无"，仿佛否定了生活的一切追求。但细想之后，我认为余华想表达的恰恰相反：它不是让你放弃追求，而是让你在失去一切追求之后，依然能活下去。在顺境中，我们为理想、为爱人、为事业而活，这很好。但人生无常，命运不会按照我们的剧本走。当理想破灭、亲人离散、一切归零的时候，人靠什么撑下去？余华的回答是：靠活着本身。 生命不需要被"意义"来拯救，呼吸本身就是奇迹，心跳本身就是尊严。

这其实是一种极其温暖的思想。它告诉我们：你不需要功成名就才配活着，不需要被爱才有资格存在，不需要"活出意义"才算不虚此行。你活着，这件事本身，就已经足够了。在当下这个充满焦虑的时代——我们被要求"活出精彩""实现自我""成为更好的自己"——余华用福贵的一生提醒我们：平凡地、安静地、甚至孤零零地活着，本身就是一种了不起的力量。

今天大家口中的“AI 编程”，其实常把三层东西混在一起说。最底层是 LLM 这样的基础模型，中间层是把模型放进“能看文件、能跑命令、能调用工具、能维护状态”的 Agent；最上层才是开发者真正天天接触的入口，例如 CLI、IDE 插件、GitHub 上的云端代理。

在 LLM 的语境里，广义的 Agent 不是“更大的模型”，而是以模型为决策核心、能规划、能调用工具、能维护上下文、能完成多步任务的软件系统。Coding Agent 则是广义 Agent 在软件工程领域的特化版本，它面向的是代码仓库、终端、测试、Git、Issue/PR、设计文档和第三方开发工具等环境。

从计算成本上也需要分开看。从技术上来说，这类系统都底层都在处理 token。但从商业上说，开发者显然未必总是按 token 原样付费。目前的计费方式包括：按输入/输出 token 计费、缓存 token 计费、隐藏 thinking token 计费、按 premium requests 计费，以及按“每 5 小时请求额度/每周请求额度/每月请求额度”订阅的混合模式。

LLM 如何走到 Coding Agent

从技术起点看，现代 LLM 的底层仍然是“对 token 序列做条件生成”的模型。2017 年的 Transformer 论文奠定了注意力机制这条主线，GPT-3 则证明了大规模参数与数据扩展可以显著提升 few-shot 能力。因此今天的大多数编程助手，表面上像在“帮你写代码”，底层本质仍然是在做高维度的 token 预测与条件生成。

面向编程的能力随后沿着两条路线演进。第一条路线，是在代码数据上进一步训练的专用模型。第二条路线，则是把更通用的前沿模型做成“能处理开发任务”的系统能力：更长的上下文、更好地推理、更强的多模态能力、更强的工具调用能力。再往前一步，就是从“模型回答问题”进入“模型参与执行工作”。各家大模型厂商近两年的官方平台就是把这种模式产品化，如 Claude Code 和 Codex。

如果把 LLM 当作文字推理引擎，那么广义 Agent 就是让这个引擎在环境中持续做事的应用形态。OpenAI 的定义很直接：

Agent 是计划、调用工具、跨专家协作并保持足够状态以完成多步工作的应用程序。

Anthropic 的表述则更工程化：

Workflow 通过预定义代码路径把 LLM 与工具串起来，Agent 则允许 LLM 动态决定自己的过程与工具使用。

简单来说，智能体可以表述为“模型 + 工具 + 循环”，直到达到停止条件为止。这一区分非常关键，因为很多开发者口中的“Agent”其实并不是完全自治体，而是“带一点自主性的工作流”。比如：

• “读取报错日志 → 搜索项目文件 → 给出修复建议”的脚本：Workflow
• 一个会自己决定先读哪些文件、要不要运行测试、需不需要继续搜索网络资料、何时请求你批准写入代码的系统：Agent

因此，今天的 AI 编程能力已经不适合只按模型排行榜来理解。更准确的理解方式是：模型能力决定上限，Agent Loop 决定能否把上限转化成真实开发产出。同一个模型，放进不同的权限边界、不同的工具集和不同的上下文管理策略里，开发体验会差非常多。OpenAI 专门写了 Codex agent loop 的工程拆解，Anthropic 也在 Claude Code 最佳实践里强调“先探索、再计划、再编码”。这说明行业竞争的重点，已经部分从“谁更会回答”转向“谁更会工作”。换言之，Coding Agent 与广义 Agent 的关系，本质上是“子集”关系。Coding Agent 是把广义 Agent 的规划、工具调用、状态管理和多步执行，放进了软件工程环境里：代码库、文件系统、终端、测试框架、lint、版本控制、Issue/PR、设计文档、MCP 工具、CI/CD 等，都是它的“世界”。

但是，也需要明确指出，Agent 的核心收益主要来自上下文管理、专业分工和并行化，但代价通常是更多 model calls、更高的 token 消耗与更复杂的调度。

为什么是 CLI

CLI（Command Line Interface，命令行界面）是一种通过文字命令与计算机操作系统或软件进行交互的界面，通俗的理解就是俗称的“终端”。为什么现有的顶级 Agent 都会采取这种形式？原因很简单，应用程序随着框架的变化，架构设计是会改变的。而操作系统的接口无论如何都是不会变的，至少不会短期内剧烈变化。

举个简单的例子，早期的 AI IDE 大多基于 vscode，采用插件的形式进行辅助编码。但结果呢？受限于 vscode 自身的限制，文件的读取、写入、搜索都需要 vscode 提供底层支持才能进行。而 cursor 的横空出世告诉人们：可以 All in AI。CLI Coding Agent 就是秉持这一观念，你可以通过对话命令 CLI 调用系统接口，例如 Windows 的 Powershell 或是 Linux 下的 Bash，来实现任意的文件操作，进而进行编码。相对应的，也可以命令 Agent 执行指令。于是你会发现，“编码 + 指令”，已经构成了完整的 develop 过程。

复杂的 Token 计费模式

天下熙熙皆为利来，天下攘攘皆为利往。互联网企业在 21 世纪已经对产品推广模型形成了一种路径依赖，这也是各位能够免费使用 GPT、Gemini、Qwen、豆包等模型的原因。

从技术定义上说，token 是模型内部处理信息的最小单位之一，它可能是一个单词、一个字符，甚至是字节/Unicode 级别的片段（例如图片、音频）。对于模型接口，上下文窗口、输出上限、缓存命中、并行工具调用成本，最后都会落在 token 上。而 tokenization 指的就是把原始文本切成 token 的过程，针对这一过程，各大厂商使用的 tokenizer 当然不同。因此，不同 tokenizer 会影响词表大小、效率和 OOV 处理方式。

从计费模式上说，在 API 世界里，只需以输入 token 与输出 token 为基本计费单位，然后叠加缓存、批处理、工具和长上下文的差异化收费，通过简单地相乘再相加即可得到资费详情。但除此之外，还有两类“看不见但会付钱”的 token。第一类是工具开销：在 Anthropic 文档里，tools 参数、tool_use、tool_result，乃至自动插入的 tool-use system prompt，都会进入 token 计费。第二类是思考或推理开销：Gemini 定价页直接把输出价格标注为 “including thinking tokens”；Anthropic 也写明即使你最后只看到了被总结后的内容，extended thinking 也是按完整 thinking tokens 计费的。这意味着，对于 Agent 来说，“让模型多想一步”往往确实能提升质量，但它并不免费。

而在 LLM API 之外，，一个令人头疼的现状是，计费和 token 的关系不再是一条直线。在计费方式上，由于 token 的开销急剧增长，计费和 token 直接划等号的计算方式似乎有点令人难以接受。于是，秉持着太阳底下没有新鲜事的原则，各大厂商火速推出了自家的 Coding Plan。通常来说，是按照“每 5 小时、每周、每月”的请求额度管理。具体到各个厂商，有的是背后是按照消耗的 tokens 进行统计，有的是按照请求数进行统计。例如单次提问会按实际模型调用次数扣额度，简单任务大约消耗 5–10 次，复杂任务可能 10–30+ 次等。这意味着，哪怕你 prompt 很短，只要 Agent 在底层反复读文件、调工具、重试验证，额度照样会快速下降。

这种计费方式的转变直接带来几个问题。首先是资源消耗不再透明，从用户端很难控制模型的请求次数，绝大多数操作都由 Agent 接管，在 LLM 引导 Agent 犯傻时，甚至会空跑额度去做大量无意义的工作。其次是，当即用即停的权力被“套餐”被包裹时，购买 Coding Plan 的决策很难说是一种便宜还是一个陷阱。就现状而言，各大厂商的 Coding Plan 或类似产品朝令夕改、霸王条款已经屡见不鲜。尤其是某些地方决策层莫名其妙地联合企业推行龙虾这种东西，导致国产算力不足的缺陷被进一步放大。一键式部署龙虾意味着一大批人将轻松的挤兑甚至挥霍本就捉襟见肘的算力，进而引发厂商的极端化应急处理，比如粗旷的封杀账号。

当然，从商业角度看，Coding Plan 必然是赔本赚吆喝的前期战略举措，而也有企业反其道而行之，不愿意随大流。小米推出的 Token Plan 在 Coding Plan 的基础上，不做花里胡哨的限制，直接按照 tokens 数量进行套餐售卖。但代价就是该套餐属于盈利性产品，因此价格相比其他厂家套餐会极其昂贵（因为其他厂家真的是在亏本卖）。

[!tip] 在 MS Office 已经支持 LaTeX 的今天，某种意义上说，这不是一个好的工具，使用它只是一个过时的、荒诞的、无奈的妥协。

本文基于 MathType 7.4.9.49，提取码：koop

安装注意事项

1. 🌟🌟🌟 在新电脑安装时，发现了一个非常现代化的问题。对于新款设备，基本都是高分辨率屏幕，而这会导致 MathType 的 exe 安装程序，在双击后可以加载，但无法显示选择安装路径等后续操作。 解决方案：右键安装程序 - 属性，设置为低分辨率（640x480）下运行即可。
2. 如果成功安装，并且软件一切正常，但就是无法将窗口显示到前台（即只能从任务栏缩略图看见），尝试修改注册表 HKEY_CURRENT_USER\Control Panel\Desktop\ForegroundLockTimeout 为 3，然后重启电脑。该问题极其少见，请谨慎处理注册表。（也可能是多显示器，窗口超出界面了）

分辨率问题

https://zhuanlan.zhihu.com/p/650006277

启动慢

我很抵触 MathType 的一个原因就是，这玩意的操作逻辑十分丑陋，每次插入公式都是启动一个新的进程来完成，可以类比为每次发送一条 QQ 消息都要重新启动一次 QQ😅。

对于这个问题，有两种方案：

1. 如果安装的 MathType 有服务器模式，打开它。你的右下角任务栏会多出糊得跟马赛克一样的图标 MathType server/服务器。让这玩意驻留后台就可以避免频繁冷启动。
2. 也可以开启一个 MathType 进程但不关闭，也就是插入一条公式，但 ctrl + s 保存后不退出编辑窗口。这样也能实现秒启动 MathType。

调整公式大小

上方导航栏 - 大小 - 定义

公式编号&右对齐

https://www.mathtype.cn/jiqiao/mathtype-jdxfz.html

编号右对齐后，如果还需要公式居中：

1. 在公式左边再按一下 Tab，此时是按照上述右对齐的方式设置的 Tab
2. 双击左边的 Tab 会灰色高亮选中，然后右键 段落，将这个制表符修改为栏宽/2。例如栏宽 26 字符，这里就设置 居中对齐，无 引导符，位置 13字符

修改公式编号字体

word 中搜索 应用样式，下拉菜单找到 MTDisplayEquation，修改即可

公式引用

MathType 的公式引用 bug 有点多，还是 MS Word 域代码吧。

下载 texlive 并装载。装载 ISO 完成后，执行批处理文件安装。

考虑到一些人可能对 ISO 文件没有概念，这里详细说一下具体的操作流程。如果你能顺利的完成上一步骤，分割线内的操作可以略过。

点击上面的下载地址，选择下载最新的（你看到的时候不一定是 2024 了）texlive$year.iso 文件即可。

找到下载的文件，鼠标右键，找到 装载 选项，点击它，完成后你会发现有一个新的 DVD 驱动器装载到了你的电脑（如下图）。ISO 文件是一种光盘镜像文件，常用于存储光盘的内容，如 CD 或 DVD 的数据，这里你可以理解为 texlive 的安装包通过一个虚拟的 U 盘插在了你的电脑上，现在你只需要进去找到安装文件执行就 OK 了。

右键这个驱动器，打开它，你就可以成功找到 文章开头 提到的批处理安装文件。

或者你直接双击上方图片的这个驱动器也行，会自动弹出安装界面的，all right？

可酌情修改安装位置。

注意，他的修改很有意思，子路径是分割开的进行设置的，所以一般只需要修改盘符即可。

点击 Advanced 进入高级设置菜单，这里还可以设置一些东西。

首先是语言。通常情况下中文 + 英文即可。在 Customize 菜单中，勾选 “Chinese”、“C hinese/Japanese/Korean (base)”，再往下拉，勾选 “US and UK English”，然后点击 “确定”。

准备就绪后，点击右下角“安装”。

安装过程涉及大量 4K 小文件读写，硬盘拉跨可能会很慢，请耐心等待。

LaTex 发行版部署 (Linux)

安装来源同 Windows 一致，仍然需下载 texlive ISO。

[!tip] 如果使用 WSL 进行部署，无需迁移复制，直接跨文件系统读取即可。

挂载镜像

sudo mkdir /mnt/texlive
sudo mount /mnt/d/Downloads/texlive2026.iso /mnt/texlive

启动安装程序

cd /mnt/texlive
sudo ./install-tl

安装配置

[!warning] 本节为可选内容，你可以在启动安装程序后直接输入 I 进行安装。

启动安装程序后，可以在终端看到如下内容：

输入 C 进行安装组件配置：

===============================================================================
Select collections:

 a [X] Essential programs and files      w [X] Italian
 b [X] BibTeX additional styles          x [X] Japanese
 c [X] TeX auxiliary programs            y [X] Korean
 d [X] ConTeXt and packages              z [X] Other languages
 e [X] Additional fonts                  A [X] Polish
 f [X] Recommended fonts                 B [X] Portuguese
 g [X] Graphics and font utilities       C [X] Spanish
 h [X] Additional formats                D [X] LaTeX fundamental packages
 i [X] Games typesetting                 E [X] LaTeX additional packages
 j [X] Humanities packages               F [X] LaTeX recommended packages
 k [X] Arabic                            G [X] LuaTeX packages
 l [X] Chinese                           H [X] MetaPost and Metafont packages
 m [X] Chinese/Japanese/Korean (base)    I [X] Music packages
 n [X] Cyrillic                          J [X] Graphics, pictures, diagrams
 o [X] Czech/Slovak                      K [X] Plain (La)TeX packages
 p [X] US and UK English                 L [X] PSTricks
 s [X] Other European languages          M [X] Publisher styles, theses, etc.
 t [X] French                            N [ ] Windows-only support programs
 u [X] German                            O [X] XeTeX and packages
 v [X] Greek
 P [X] Mathematics, natural sciences, computer science packages
 S [X] TeXworks editor; TL includes only the Windows binary

Actions: (disk space required: 9388 MB)
 <-> deselect all
 <+> select all
 <R> return to main menu
 <Q> quit

Enter letter(s) to (de)select collection(s):

每个配置项通过字母进行控制，输入对应的字母并回车即可进行选中/取消选中。该过程可以反复操作，因此不必力求一次性输入所有字母。这里给出一个较为保守的取消配置方案：

knostuvxyzABC # 语言类 (保留了中/英)
iI # 游戏和音乐排版，极其小众的需求
S # 编辑器, 由于使用vscode, 因此不需要

[!tip] 完整安装其实也就 9G，上面一顿操作也就省 1G 左右空间，代价则是编译某个模板报错或者某个 Journal 模板炸了。 但是，即使有些宏包在上面精简了，后期仍然可以使用 tlmgr 工具来单独安装。因此不用太担心。

确认配置完成后，输入 R 并回车，返回上一级菜单。

开始安装

输入 I 并回车，开始安装。由于安装过程涉及大量小文件读写，因此安装时间取决于机器的硬件性能，耐心等待即可。

安装完成后，配置环境变量：

export PATH="/usr/local/texlive/2026/bin/x86_64-linux:$PATH"
export MANPATH="/usr/local/texlive/2026/texmf-dist/doc/man:$MANPATH"
export INFOPATH="/usr/local/texlive/2026/texmf-dist/doc/info:$INFOPATH"

然后注册 texlive 字体：

sudo cp /usr/local/texlive/2026/texmf-var/fonts/conf/texlive-fontconfig.conf /etc/fonts/conf.d/09-texlive.conf
sudo fc-cache -fsv

此外，Linux 上需要额外下载 ghostscript，否则 eps 转 pdf 时会失败：

sudo apt update
sudo apt install ghostscript

上述步骤做完后，即可卸载 texlive 镜像：

sudo umount /mnt/texlive

vscode 配置

首先声明，在 texlive 安装完成后，默认会自带一个编辑器 TeXworks editor，是可以正常使用的。但谁能拒绝宇宙第一开源编辑器 vscode 呢🤣。

只需要安装插件 LaTex Workshop 即可让 vscode 支持 LaTeX 编辑。此外，还需要添加如下配置文件。

注意，该配置仅需工作区生效即可。

如果不清楚 vscode 的分区管理，那就在项目根目录下新建一个 .vscode/settings.json，然后将下面配置复制粘贴进去即可。

{
    //输出文件的保存目录(会自动在当前路径下创建build文件夹)
    "latex-workshop.latex.outDir": "%DIR%/build",
    //光标在公式上时会自动悬浮渲染
    "latex-workshop.mathpreviewpanel.cursor.enabled": true,
    //使用默认的(第一个)编译链自动构建 LaTeX 项目
    "latex-workshop.latex.autoBuild.run": "onSave",
    "latex-workshop.showContextMenu": true,
    //从使用的宏包中自动提取命令和环境，补全正在编写的代码
    "latex-workshop.intellisense.package.enabled": true,
    //文档编译错误时是否弹出显示出错和警告的弹窗(都可从终端获取)
    "latex-workshop.message.error.show": false,
    "latex-workshop.message.warning.show": false,
    //定义编译工具
    "latex-workshop.latex.tools": [
        {
            "name": "xelatex",
            "command": "xelatex",
            "args": [
                "-synctex=1",
                "-interaction=nonstopmode",
                "-file-line-error",
                "--output-directory=%OUTDIR%",
                "%DOCFILE%" //%DOC%
            ]
        },
        {
            "name": "pdflatex",
            "command": "pdflatex",
            "args": [
                "-synctex=1",
                "-interaction=nonstopmode",
                "-file-line-error",
                "--output-directory=%OUTDIR%",
                "%DOCFILE%"
            ]
        },
        {
            "name": "latexmk",
            "command": "latexmk",
            "args": [
                "-synctex=1",
                "-interaction=nonstopmode",
                "-file-line-error",
                "-pdf",
                "-outdir=%OUTDIR%",
                "%DOCFILE%"
            ]
        },
        {
            "name": "bibtex",
            "command": "bibtex",
            "args": [
                "build/%DOCFILE%"
            ]
        }
    ],
    //定义编译链
    "latex-workshop.latex.recipes": [
        {
            "name": "XeLaTeX",
            "tools": [
                "xelatex"
            ]
        },
        {
            "name": "PDFLaTeX",
            "tools": [
                "pdflatex"
            ]
        },
        {
            "name": "BibTeX",
            "tools": [
                "bibtex"
            ]
        },
        {
            "name": "LaTeXmk",
            "tools": [
                "latexmk"
            ]
        },
        {
            "name": "xelatex -> bibtex -> xelatex*2",
            "tools": [
                "xelatex",
                "bibtex",
                "xelatex",
                "xelatex"
            ]
        },
        {
            "name": "pdflatex -> bibtex -> pdflatex*2",
            "tools": [
                "pdflatex",
                "bibtex",
                "pdflatex",
                "pdflatex"
            ]
        },
    ],
    //编译完成后要清除掉的辅助文件类型(如无需求，请勿修改)
    "latex-workshop.latex.clean.fileTypes": [
        "*.aux",
        "*.bbl",
        "*.blg",
        "*.idx",
        "*.ind",
        "*.lof",
        "*.lot",
        "*.out",
        "*.toc",
        "*.acn",
        "*.acr",
        "*.alg",
        "*.glg",
        "*.glo",
        "*.gls",
        "*.ist",
        "*.fls",
        "*.log",
        "*.fdb_latexmk"
    ],
    //何时对上文设置的辅助文件进行清除
    "latex-workshop.latex.autoClean.run": "onFailed",
    //设置默认编译链
    "latex-workshop.latex.recipe.default": "pdflatex -> bibtex -> pdflatex*2",
    //反向同步快捷键绑定
    "latex-workshop.view.pdf.internal.synctex.keybinding": "double-click",

    "[latex]": {
        "editor.wordWrap": "on",  //自动换行
        "editor.wordWrapColumn": 80
    },
}

理论上说，安装过程中会自动配置环境变量，从而让 xelatex 等命令全局生效。但如果编译时一直检测不到，可以换成绝对路径引用，或者尝试重启电脑。

看不懂上面的内容就看这里。你要做的是三件事：

1. 下载安装 vscode
2. 下载一个叫做 LaTex Workshop 的插件，图标是一个钢笔一样的东西
3. 在 vscode 中打开你的 LaTeX 模板文件夹
4. 在这个文件夹的根目录下，新建一个文件夹 .vscode，然后在 .vscode 文件夹里再新建一个 settings.json 文件
5. 把上面的配置文件内容复制粘贴到 settings.json，保存
6. 你的 vscode 右侧会多出一个 LaTeX 的操作面板，点进去试吧
7. 还有任何不会用的就百度去，只要你投的不是什么十分野鸡的期刊，网上很容易就能找到 LaTeX 模板的使用方法

LaTex Workshop 占位符说明

参考 https://github.com/James-Yu/LaTeX-Workshop/wiki/Compile#placeholders

首先在配置项 outDir 中指定全局输出路径，这里 %DIR 指工作区根路径：

"latex-workshop.latex.outDir": "%DIR%/build",

注意编译前请提前创建好对应路径 build/

然后，在各编译器中，即可使用占位符 %OUTDIR% 表示输出路径。

参考官方文档：“%OUTDIR% is the output directory configured in latex-workshop.latex.outDir”

以 xelatex 编译器为例，可以看见其输出参数为 -output-directory：

xelatex -help

-output-directory=DIR   use existing DIR as the directory to write files in

因此配置编译工具 latex-workshop.latex.tools：

// 使用占位符 %OUTDIR%
{
    "name": "xelatex",
    "command": "xelatex",
    "args": [
        "-synctex=1",
        "-interaction=nonstopmode",
        "-file-line-error",
        "--output-directory=%OUTDIR%",
        "%DOCFILE%"
    ]
}

类似的，为 latexmk 添加参数：

{
    "name": "latexmk",
    "command": "latexmk",
    "args": [
        "-synctex=1",
        "-interaction=nonstopmode",
        "-file-line-error",
        "-pdf",
        "-outdir=%OUTDIR%",
        "%DOCFILE%"
    ]
}

但注意，bibtex 没有该参数，直接通过 bibtex xxx 进行编译，因此修改为:

{
    "name": "bibtex",
    "command": "bibtex",
    "args": [
        "build/%DOCFILE%"
    ]
}

[!caution] 注意这里 bibtex 的配置，需指定参数为 build/ 而不是用占位符 %OUTDIR% 代替，这是由于 LaTeX 的安全考虑，可参考如下链接：

• 解决问题：bibtex.exe: Not writing to xxx/xxx.blg
• bibtex error: Not writing to book.blg (openout_any = p)

中文支持

参考 overleaf latex Chinese

推荐使用 XeLaTeX 和 LuaLaTeX 来编译含有中文字符的 .tex 文件：

1. 直接使用 ctexart 文档类即可支持中文
2. 或者使用 ctex 包来支持中文

\documentclass{ctexart}

\begin{document}
\tableofcontents

\begin{abstract}
这是简介及摘要。
\end{abstract}

\section{前言}

\section{关于数学部分}
数学、中英文皆可以混排。You can intersperse math, Chinese and English (Latin script) without adding extra environments.

這是繁體中文。
\end{document}

或者

\documentclass{xxx}
\usepackage{ctex}

latexdiff

[!tip] 本节内容需要你在撰写文档时，使用 Git 进行了版本控制。

换言之，如果你对工程项目的管理使用的是复制粘贴大法，恕我爱莫能助。

1. 确认环境

在命令行（cmd 或 PowerShell）里输入：

latexdiff --version

如果能看到版本号，说明 TeXLive 已经带有 latexdiff。

如果报错，就需要安装（TeXLive 通常自带）。

2. 使用 git 导出不同 commit 的文件版本

假设论文主文件叫 paper.tex，你有两个 commit：

• 老版本：OLD_COMMIT
• 新版本：NEW_COMMIT

可以这样导出：

git show OLD_COMMIT:paper.tex > old.tex
git show NEW_COMMIT:paper.tex > new.tex

这样你就得到了 old.tex 和 new.tex 两个版本。通常情况下，new.tex 就是当前修改完成的版本，因此只需要根据 commit 记录导出修订前的版本即可。

3. 用 latexdiff 生成标记文档

[!caution] latexdiff 本质是“文本级 diff”，它不理解 LaTeX 结构，所以 99% 的情况下，生成的标记文档是无法编译成功了。请耐心排查问题，虽然这很麻烦，但相比于你手动修订还是快很多的。

当然，你也可以选择 WORD 投稿 🤝

如果你能理解 latexdiff 的风险，那么可执行以下指令：

latexdiff --math-markup=1 \
          --disable-citation-markup \
          --config="PICTUREENV=(?:figure|table|table*|tabular|tabular*)" \
          --exclude-textcmd="section,subsection,subsubsection,caption" \
          old.tex new.tex > diff.tex

上述命令相比于默认的 latexdiff 操作，做了如下几件事情：

1. 保留默认对数学环境的标记。
2. 禁止对引用命令的内容做差异标记：即使两个版本中 \cite{A} 变成了 \cite{B}，也不会显示为“删除 A、新增 B”，而是整体视为未变或原样保留。
3. 扩展 latexdiff 认为“不应拆分内部内容”的浮动体/表格环境列表：对声明的环境视为一个不可分割的单元，不在内部插入 \DIFadd 或者 \DIFdel
4. 指定部分命令的参数不参与字词级差异分析，而是作为整体处理：包括各级标题、图表名。

需注意，上述指令关闭了一些内容的对比生成，但不代表你应该忽视。对于一些重要的改变，你应当手动注明修改：添加 DIFadd/DIFdel 标记等。此外，如存在大量复杂公式，则 --math-markup=1 仍可能导致编译失败，可尝试置其为 0 以避免数学公式的嵌套标记生成。

如果碰上字符集报错，例如：

latexdiff .\origin.tex .\sn-article.pdf > major_diff.tex

utf8 "\xD0" does not map to Unicode at f:\texlive\2024\texmf-dist\scripts\latexdiff\latexdiff.pl line 1826, <FILE> chunk 1.
Either both texts must have preamble or neither text must have the preamble.

可通过手动指定字符集解决：

latexdiff --encoding=utf8 .\origin.tex .\sn-article.tex > major_diff.tex

然后编译生成的对比文档即可获得带修订版本的稿件。

参考

• shinyypig/latex-vscode-config
• blog.iw17.cc/install-latex
• blog.iw17.cc/vscode-latex
• 知乎：Visual Studio Code (vscode)配置LaTeX

主要工具包括：Inkscape，Ghostscript，Image Magick。搜索 格式a-格式b 可快速检索，例如 PDF-EMF。

[!tip]

1. 并不是说每一类工具只能进行如下列举的格式转换，但是不同工具各有所长，因此只给出推荐的格式转换。
2. 本文不定时更新。

二、Inkscape

# PDF-EMF: latex论文图片转word
inkscape input.pdf --export-type=emf --export-filename=output.emf

# SVG-EMF: matplotlib输出矢量图转word
inkscape input.svg --export-type=emf --export-filename=output.emf

注意，如果 PDF 是 matplotlib 绘制的，需确保代码中设置 Type1 或 TrueType 字体，否则默认的 Type3 字体将导致 Inkscape 解析失败：

plt.rcParams.update({
    "pdf.fonttype": 42,      # 使用 TrueType 字体（Type42），兼容性最好
    "ps.fonttype": 42,       # 同时设置 PostScript 字体类型（以防转 EPS）
})

三、Ghostscript

# PDF-EPS: 矢量图转上古期刊图片
gswin64c.exe -sDEVICE=eps2write -dPDFSETTINGS=/prepress -dNOPAUSE -dQUIET -o "taxonomy.eps" "taxonomy.pdf"

• *.eps 文件是输出文件，*.pdf 文件是输入文件
• -dPDFSETTINGS 可选：
  • /screen：适用于屏幕显示，压缩图像，适当降低质量，减小文件大小。
  • /ebook：适合电子书，图像质量适中。
  • /printer：适合打印，高质量的图像。
  • /prepress：用于出版行业，最高质量输出 (通常用这个就行)。

四、Image Magick

# 批量转换-PDF: 通常情况下，通过代码/程序可以直接输出 PDF 格式图片。但如果存在部分位图需要转换，可通过 image magick 实现
magick mogrify -format pdf -compress zip *.png

# 单一转换-PDF
magick input.jpg -compress zip output.pdf

文件 - 选项 - 高级，取消勾选 智能段落选择

页眉/页脚

插入 - 页眉/页脚

底部横线

选中页眉/页脚中的内容（空白就选中回车符），点击 开始 - 边框 - 边框和底纹

调节颜色、样式、宽度等，然后点击设置 下框线。

[!tip] 注意，如果是上粗下细的文武线，要选择显示效果上细下粗的那个样式，反之亦然。不知道为什么是反过来的。

奇偶页不同

双击页眉/页脚后，进入 页眉和页脚 ，勾选 奇偶页不同

[!tip] 设置页码奇偶页不同：同上，勾选 奇偶页不同 ，添加页码后，复制奇数页生成的页码，复制粘贴到偶数页，切记不能手动输入！

内部内容对其

页眉和页脚 - 插入对齐制表符位

[!warning] 这个对其制表符可以插入多个，所以如果页码和内容由间隔，例如页码居左 & 内容居中，只需要多次插入即可

页眉插入章节标题

插入 - 文档部件 - 域 - StyleRef (倒数往下找)，选择 域属性（就是你要引用哪个样式，通常是标题 1），勾选右侧 插入段落编号。

脚注

脚注生成的文本是可以直接调整格式的，正常调整即可。

调整脚注上方的“脚注分隔符”：先切换到草稿视图 视图 - 草稿，然后在 引用 中，点击 显示备注。在下方下拉菜单中，选中 脚注分隔符，即可进行调整。完成后切换回 页面视图 即可。

页面布局

分栏

布局 - 栏 ，框选需要分栏的部分，选择 两栏

[!caution] 左边栏没有满，就跑到右边栏，即左右栏均匀分布的问题：主要是可能在中间部分引入了非分栏的表格等结构，导致插入了 连续分节符。默认情况下，分栏是左边满了再去右边，因此请核实 分节符 位置，尤其是审阅模式下隐藏内容里的分节符！！！

西文换行

段落 - 中文版式 - 勾选 允许西文单词在中间换行

[!tip] 参考文献两端对齐后大面积空白，可用此法解决

上标不够靠上

字体 - 高级 - 位置 改为 上升 - 磅值 按需设置即可

[!warning] 如果磅值设置后导致行距变大，请在正文的 段落 中，取消勾选 对其文档网格

好像把行间距设置为固定值就行了

样式自动更新

• 开启后，如果修改了某一标题的全部内容，则所有与之样式相同的部分都会变化
• 若关闭，则不会

[!tip] 关于自动更新，如果此前已经修改过某些使用了该样式的部分，则样式自动更新似乎不会作用于这些部分上

公式

Word - 快速输入数学公式 | JacobZ (zyxin.xyz)

Word 中使用 UnicodeMath 和 LaTeX 的线性格式公式 - Microsoft 支持

已知 office word 中与 LaTeX 不一致的地方：

# 下方约束条件
latex:  \lim\limits_{constrain}
word:  \lim\below{constrain}

公式编号

有两种方法：使用 word 进行编号，或者依赖 MathType 进行编号。

word 编号 (非 MathType)

首先说 word 明面上一种自带的公式编辑方法，即 插入 选项卡中的 编号。

# 在公式框内部的最右侧通过 #(编号)，然后回车
E=mc^2#(1)

生成效果与下方相同

$$ E=mc^2\tag{1} $$

这种方式的主要优点在于会将生成的编号自动进行右对齐，但存在一个问题：如果需要对公式进行交叉引用，在引用界面是看不到这个编号效果的。

类似这种方案，网上还可以搜索到通过 SEQ 域代码进行编号的，但不仅效果一致，而且存在的问题也一样。

参考官方文档 Seq (序列) 字段。

下面介绍 word 第二种编号方法：域。

https://zhuanlan.zhihu.com/p/109212246

1. 公式完成后，输入 #()
2. 新建一个多级列表，在 更多 选项卡内，输入 ListNum 名称 (随便自定义)
3. 在括号内， 插入 - 文档部件 - 域
4. ListNum - 选中自定义名称的列表
5. 回车，即可实现自动编号 + 右对齐

上述过程也可以通过域代码的方式进行：

1. 公式完成后，输入 #()
2. 新建一个多级列表，在 更多 选项卡内，输入 ListNum 名称 (随便自定义，例如 eq)
3. 在括号内，按 ctrl + F9 添加域，输入 listnum eq
4. 按 F9 渲染域
5. 回车，即可实现自动编号 + 右对齐

MathType 编号

太傻逼了这个，算了不写了。

最佳实践

经过较长时间的使用，总结出最佳实现方式如下：

1. 使用 SEQ 域代码进行自动编号
2. 框选生成编号，ctrl + shift + F5 进行书签生成。 这一步可以根据公式含义自行制定书签名称，便于后续交叉引用。
3. 使用 REF 域代码进行公式引用，例如 REF all_loss，其中 all_loss 为书签，对应第 2 步添加的公式书签。

MathType 公式居中，编号右对齐

1. 首先打开 布局 - 栏 - 更多栏，记录下栏宽（例如 x 字符）
2. 先将公式前的空格删除，移动到最左侧
3. 右键 段落 - 制表位
4. 制表位位置 = x 字符，对齐方式：右对齐，引导符：无
5. 在编号前按下 Tab，即可实现编号右对齐
6. 复制这个制表符，粘贴到公式左侧
7. 继续右键 段落 - 制表位
8. 制表位位置 = x/2 字符，对齐方式：居中对齐，引导符：无
9. 即可实现公式居中

经过实测，插入公式时光标顶格，保存公式后按一下 Tab 似乎可以自动跳转到当前栏的最右端。暂不清楚是否跟 MathType 的版本有关。

注意事项

1. 无论是 MS 还是 WPS，通过题注进行公式编号时，一旦删除了中间某个公式，剩余的公式虽然会重新自动编号，但是，从修改位置之后的所有题注引用会报错找不到书签。
2. 如果通过 SEQ 编号然后手动添加书签，可以使得其余位置公式正常重排，只会丢失被删除公式的书签。

表格

列表第二行内容顶头

在列表段落右键 - 调整列表缩进 - 文本缩进 设置为 0 即可

制表符问题

如果碰上那种在文中使用外侧框线表格，将文章划分为一个一个块块的文档（没错，傻逼学校文档，说的就是你），如果要在里面使用公式，按 Tab 进行对齐是不好使的，因为表格中的 Tab 默认是移动到下一格子，因此需要使用 Ctrl + Tab。

找不到“段落”设置

可以尝试以下方法：

1. 100% 可行，在开始选项卡点段落右下角的按钮即可
2. 框选表格里的一段文字，再右键点击段落

设置表边框不生效

设置三线表时，可能会出现明明设置了边框宽度，但是不生效的情况。因为边框设置生效是有顺序要求的。执行以下步骤即可：

1. 先取消对应位置表边框（例如下框线）
2. 然后设置框线厚度
3. 最后重新勾选生效对应位置的框线，即可生效。

修改表格内容字体

在面对某些特定表格，例如实验结果时，我们可能希望表格中的文本可以像正文一样，通过样式统一设置。但当我们新建一个样式后，例如：中文宋体、英文 Times New Roman，然后选中/框选整个表格，点击样式会发现无法生效。表格中文会锁定宋体，英文会锁定 Calibri。只有单独选中表格中的部分内容进行字体修改才能生效。

这是因为表格内容的样式并不是通过外部设置的，而是单独的表格样式： 选中表格 - 表设计 - 表格样式下拉菜单 - 修改表格样式

在这里面就可以对内容的字体进行修改了。

表格内容无法垂直居中

即使在表格属性中设置了单元格垂直居中，会发现文本仍然存在下边距（等效视觉为整体靠上）。解决方案为：文件 - 选项 - 高级 - 以下对象的布局选项 - 勾选 在表格中将行高调至网格高度。

三线表横线中间断开

边框和底纹 中设置框线时，作用于 下拉菜单设置为 段落 即可。注意，不同作用于的框线可以单独设置，所以取消其中的框线不会影响其他作用域的样式。

插图

图注写在图下面

图编号

通过 引用 - 插入题注 来进行图编号，注意以下几点：

1. 标签 指的是图标号前面的内容，例如 图1 ， Fig.1 ， 标签 就是 图 和 Fig
2. 你想使用的 标签 不存在时，可以 新建标签
3. 生成的题注格式为 标签<空格>序号 ，其中的 空格 属于 word 本身规定，只能手动删除
4. 插入题注 不具备样式链接功能，需要手动调整样式

设置图片大小

右键图片 - 大小和位置 可以精确设置图片大小。如果有多张图片需要调整为一致的大小，在调整好第一张后，直接选中其余图片，按 F4 即可重复刚刚的调整操作。

参考文献

zotero 插入的参考文献，是不支持自动交叉引用的。目前测试的一种可行方案如下：

1. 新建 编号 样式（不是多级列表），设置字体等样式
2. 框选所有 zotero 生成的参考文献，使用 编号
3. 删除 zotero 生成的 [数字] （其实也可以在 citation 文件中修改，待评估）
4. 修改原文中的参考文献引用即可

[!note] 注意保存好这里下载的密钥文件

安装脚本

在服务器上创建脚本运行路径：

mkdir /opt/rbot

获取并运行脚本：

cd /opt/rbot
# 下载脚本
wget -O sh_client_bot.sh https://github.com/semicons/java_oci_manage/releases/latest/download/sh_client_bot.sh
# 给执行权限
chmod +x sh_client_bot.sh
# 运行脚本
bash sh_client_bot.sh

[!note] rbot 会自动注册服务，systemctl status bot 可查看运行状态。

提示运行失败是正常的，直接 Ctrl + C 退出即可。打开产生的 client_config 文件，将 Oracle 控制台得到的 OCI 密钥按提示粘贴到指定位置：

#在oci=begin和oci=end之间放入你的API配置信息 支持多个配置文件 机器人切换profile可更换操作配置
oci=begin
[DEFAULT]
user=xxx
fingerprint=xxx
tenancy=xxx
region=xxx
key_file=./Oracle.pem
oci=end

找到刚刚下载的两个密钥文件，将其中的私钥（后缀为 .pem，不是 xxx_public.pem）重命名为 Oracle.pem，然后将其上传到 rbot 路径下即可。

然后打开 TG，执行以下步骤：

1. 首先关注 频道
2. 添加 机器人

[!warning] 关注频道是必选项，否则无法使用机器人功能。

1. 向机器人发送指令 /raninfo ，并根据提示在一分钟内重复发送一次，获得配置文件信息：

   username=xxx
   password=xxx
   

2. 继续打开 client_config 文件，将上面得到的 username 和 password 填入其中：

   #用户信息 从 https://t.me/radiance_helper_bot 配置(bot可使用/raninfo命令随机生成)
   #必传
   username=xxx
   #必传
   password=xxx
   

3. 启动客户端：

   bash sh_client_bot.sh # 默认端口9527
   # 或者
   bash sh_client_bot.sh 8888 # 可更换默认9527为8888端口
   

执行开机操作

向机器人发送 /oracle，选择 1. 开机，配置按需求进行选择。注意 确定开机 按钮需要点两次，第一次是确认，第二次是提交。

[!note]
2026-03-10：这个东西体验了几天，发现属实没什么卵用。远程操控有 UU，coding 有 codex/cc 等一大堆 CLI Agent（不会真有人写代码对着 IM 窗口狂敲吧？Diff 都不需要的吗？），其他的功能也完全可以使用 cherrystudio 等成熟客户端平替。

你可能会说，对着一个 IM 就可以完成上面的所有操作，不是更方便吗？一方面，权限问题目前没有很好的解决方案；另一方面，各家 IM 的适配有限，响应速度和 tokens 开销都是一笔不菲的成本。最重要的是，即使忽略上述两个问题，openclaw 的实际体验感也不好用啊！它不好用啊，不好用。

安装

[!warning]

1. 需 Node.js >= 22
2. 如果运行在服务器上，2G 内存是不够的！具体多少不清楚，我手头也没有那么大内存的服务器。

[!caution] Windows 下安装需要用管理员模式启动终端！

安装 openclaw

# Linux
curl -fsSL https://openclaw.ai/install.sh | bash
# Windows
iwr -useb https://openclaw.ai/install.ps1 | iex

选择对应的后端 LLM 接入，启用需要的 skills 即可。或者也可以跳过该步骤，后续手动修改。

反向代理

server {
    listen 80;
    server_name your_domain; # 替换域名

    return 301 https://$host$request_uri;
}

server {
    listen 443 ssl;
    server_name your_domain; # 替换域名

    ssl_certificate /path/to/your/fullchain.pem; # 证书文件
    ssl_certificate_key /path/to/your/privkey.pem; # 私钥文件

    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers HIGH:!aNULL:!MD5;
    ssl_prefer_server_ciphers on;

    location / {
        # 代理到 OpenClaw 本地端口
        proxy_pass http://127.0.0.1:18789;
        
        # 传递客户端真实 IP 与协议等基础头信息
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;

        # 启用 WebSocket 支持
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_http_version 1.1;
        
        # 延长超时时间
        proxy_read_timeout 86400;
        proxy_send_timeout 86400;
    }
}

接入 QQ

openclaw plugins install @sliverp/qqbot@latest
openclaw channels add --channel qqbot --token "ID:Secret"
openclaw restart gateway

[!note] 执行 plugins install 时，如果发生 npm run failed，除了常见的网络原因之外，还有一个可能是 OOM...别问我为什么知道...

FAQ

关于自启动

在 Windows 平台下，openclaw 的自启动是写在 任务计划程序 里的，在任何用户登录时，启动脚本 C:\Users\<user>\.openclaw\gateway.cmd

[!tip] 大体过程可以完全参考官方的 README 文档

首先克隆官方仓库：

git clone https://github.com/FunAudioLLM/CosyVoice.git

如果网络问题导致克隆中断，可以进入项目路径后重新执行：

cd CosyVoice
git submodule update --init --recursive

配置虚拟环境的工具，官方给出的是 conda，我这里使用 pixi 替代：

pixi init
pixi add python=3.10

pixi.toml 和 pixi.lock 参见 https://gist.github.com/sun2ot/c3e0802ccc0c706664a7a501b4d7251e

[!warning] 我的环境为：Windows 11 23H2，WSL Ubuntu-24.04 LTS，Nvidia Driver 591.86，CUDA 13.1 依赖版本仅供参考

将环境配置文件内容复制替换后，执行 pixi install 即可。

预训练模型下载

参考官方文档中的 Model download 部分，按照国内外不同网络环境使用脚本下载即可。例如国内环境下，创建 model_dl.py 文件：

from modelscope import snapshot_download
snapshot_download('FunAudioLLM/Fun-CosyVoice3-0.5B-2512', local_dir='pretrained_models/Fun-CosyVoice3-0.5B')
snapshot_download('iic/CosyVoice2-0.5B', local_dir='pretrained_models/CosyVoice2-0.5B')
snapshot_download('iic/CosyVoice-300M', local_dir='pretrained_models/CosyVoice-300M')
snapshot_download('iic/CosyVoice-300M-SFT', local_dir='pretrained_models/CosyVoice-300M-SFT')
snapshot_download('iic/CosyVoice-300M-Instruct', local_dir='pretrained_models/CosyVoice-300M-Instruct')
snapshot_download('iic/CosyVoice-ttsfrd', local_dir='pretrained_models/CosyVoice-ttsfrd')

然后执行 python model_dl.py 即可。所有模型总共需占用 32G，如果仅需要音色克隆，则只需下载 FunAudioLLM/Fun-CosyVoice3-0.5B-2512 即可（可能是的，我没试过）。

代码修改

由于 torchaudio 与官方版本不一致，因此导致 .info() API 存在不兼容。修改 webui.py 如下内容即可：

if mode_checkbox_group in ['3s极速复刻', '跨语种复刻']:
    if prompt_wav is None:
        gr.Warning('prompt音频为空，您是否忘记输入prompt音频？')
        yield (cosyvoice.sample_rate, default_data)
    waveform, sr = torchaudio.load(prompt_wav)
    # if torchaudio.info(prompt_wav).sample_rate < prompt_sr:
    if sr < prompt_sr:
        # gr.Warning('prompt音频采样率{}低于{}'.format(torchaudio.info(prompt_wav).sample_rate, prompt_sr))
        gr.Warning(f'prompt音频采样率{sr}低于{prompt_sr}')
        yield (cosyvoice.sample_rate, default_data)

启动

终端执行 python webui.py --model_dir pretrained_models/Fun-CosyVoice3-0.5B，启动后访问 http://localhost:8000 即可看到 webui 界面。

注意两个问题：

1. 音色克隆除了音源以外，还需要对应的标签，即与音频对应的文本。但由于是零样本生成，因此准备几秒的音频即可，手动录入文本标签并不会很困难。
2. prompt文本 可能存在 bug，参考 issue1703，要在你的提示词前面加上 You are a helpful assistant.<|endofprompt|>，否则亲测会报错。

安装

Windows 11 内置了 wsl.exe，可以在 shell 中直接调用

# 查看帮助信息
wsl --help

# 查看当前有效的分发列表
wsl --list --online

# 安装发行版
wsl --install -d Ubuntu-24.04

基本操作

wsl basic commands

# 关机
wsl --shutdown

# 查看版本
wsl --version

wslconfig

官方文档

默认情况下，通过 wsl 安装的是 WSL2，WSL（或者说 WSL1 已经停止维护）。.wslconfig 即为 WSL2 使用的配置文件。

.wslconfig 默认情况下不存在，需手动在 C:\Users\<UserName> 下新建一个。

[!warning] 修改配置后，必须关闭 wsl 然后重启才能生效

主要配置项

官方文档

WSL 网络

NAT（默认）

默认情况下，WSL 使用基于 NAT（网络地址转换）的网络体系结构。按照 官方文档 的描述，从 Windows 访问 WSL 应用，居然是访问 localhost？？这太他妈迷惑了。

而从 WSL 访问 Windows，按照 WSL 的网络结构，显然可以通过 Windows 的 IP 地址访问，但也可以通过 ip route show | grep -i default | awk '{ print $3}' 获取的 IP 进行访问，而且这个 IP 和 Windows 真正的局域网 IP 并不一致。

镜像（推荐）

[!tip] 官方现在有图形化界面，直接在网络模块中设置为 Mirrored 即可。

Windows 22H2 以后支持一种更加优雅的网络解决方案：“镜像网络”。启用此功能会将 WSL 更改为全新的网络体系结构，其目标是将 Windows 上的网络接口“镜像”到 wsl 中，以添加新的网络功能并提高兼容性。

开启该模式需要在 .wslconfig 中配置：

[wsl2]
networkingMode = mirrored

然后使用管理员权限在 PowerShell 窗口中运行以下命令，以 配置 Hyper-V 防火墙 设置，从而允许入站连接：

Set-NetFirewallHyperVVMSetting -Name '{40E0AC32-46A5-438A-A0B2-2B479E8F2E90}' -DefaultInboundAction Allow

或者

New-NetFirewallHyperVRule -Name "MyWebServer" -DisplayName "My Web Server" -Direction Inbound -VMCreatorId '{40E0AC32-46A5-438A-A0B2-2B479E8F2E90}' -Protocol TCP -LocalPorts 80

WSL 存储

[!tip] 尽量不要在 WSL 里去频繁跨系统读写 Windows 磁盘中的内容！速度相对而言非常慢

Windows 中的磁盘，即 C/D/... 等磁盘，在 WSL 中以挂载形式呈现，即 /mnt/c,d... 等。此外，你可以在 Windows 的文件资源管理器中看到 WSL 的存储位置。但是，这一切都是通过网络连接的，而一张千兆网卡的速度也就是 100MB/s 左右。所以你会看到，一张 pice4.0 顺序读写 7000 MB/s 的磁盘，从磁盘写入 WSL 的速度只有可怜的 100 MB/s。只能说方便的代价就是极度的性能损失。

FAQ

应该使用 WSL 吗？

• 如果只是为了包管理器，scoop 足矣
• 如果写轻量项目，Windows 也完全足够
• 但如果有 Linux 的专属需求，例如 python 深度学习的某个包不支持 Windows，那不妨来试试 WSL，确实挺好用

代理

使用 WSL2 时，可能会遇到报错：

wsl: 检测到 localhost 代理配置，但未镜像到 WSL。NAT 模式下的 WSL 不支持 localhost 代理。

在 WSL1 时代，由于 Linux 子系统和 Windows 共享了网络端口，所以访问 Windows 的代理非常简单。例如 Windows 的代理客户端监听了 8000 端口，那么只需要在 Linux 子系统中执行如下命令，就可以让当前 session 中的请求通过代理访问互联网。

export ALL_PROXY="http://127.0.0.1:8000"

但是 WSL2 基于 Hyper-V 运行，导致 Linux 子系统和 Windows 在网络上是两台各自独立的计算机，从 Linux 子系统访问 Windows 首先需要找到 Windows 的 IP。

所以解决该问题，可以在 .wslconfig 中关闭自动代理。注意，按照微软 官方文档 的最新版，autoProxy 已经不再属于实验性设置 [experimental]，而是属于主要设置 [wsl2]：

[wsl2]
# 在该节下新增配置
autoProxy = false

当然，你也可以按照 issue 让自动代理正常工作，而不是关闭。

nvidia 驱动与 cuda 问题

如果 windows 主系统中已安装了 nvidia 驱动，ubuntu 中不要再额外安装了，可以直接通过 nvidia-smi 查看。

移动 WSL

[!tip] 2026.03.02 更新：wsl --manage 可以直接移动发行版位置。在 --shutdown 后，直接通过 wsl --manage Ubuntu-24.04 --move "F:\wsl\ubuntu2404"

默认情况下，wsl 会安装在 C 盘。如果追求极致的稳定性，其实是不推荐移动的。但如果确实要移动，也有办法：

# 查看当前子系统状态
wsl -l -v

# 需要先停止子系统运行
wsl --shutdown

# 导出子系统
wsl --export Ubuntu-20.04 D:\ubuntu20-04.tar

注意，这里导出的发行版名称严格与 wsl -l -v 的结果相对应，即：

NAME            STATE           VERSION
* Ubuntu-20.04    Exporting       2

完成上述操作后，原有子系统仍然存在，且导出目录下会多出一个对应的归档文件。接下来需要删除原有系统：

wsl --unregister Ubuntu-20.04

这一步完成后，原系统占据空间将被释放。然后导入归档文件：

# --import 发行版 安装位置 文件名 [选项]
wsl --import Ubuntu-20.04 D:\Ubuntu-20.04-wsl  D:\ubuntu20-04.tar --version 2

重新安装子系统后，默认登录用户会重置为 root，所以还需要修改默认登录用户：

ubuntu2004.exe config --default-user root

继上一次 解决毒瘤深信服easyconnect，校方随大流已将 VPN 升级为深信服的 aTrust。当然，🐶改不了吃💩，软件换皮不能改变其强兼你电脑的本质。好在互联网冲浪时发现浙江大学的同学提供了 ZJU RVPN 客户端的 Go 语言实现，经实测其可完全使用与常规 aTrust VPN 的使用场景。

下载

下载 zju-connect 的 beta 或者 nightly 版本。由于是独立二进制文件，因此解压后即可使用。如果是生产环境上需要，也可以考虑 Docker 部署。

配置文件

zju-connect 以 toml 作为配置文件，配置字段可参考 参数说明。下面给出一个基本配置文件：

protocol = "atrust"
# 修改为学校的 vpn 地址
server_address = "vpn.nmu.edu.cn"
server_port = 443
username = "账号"
password = "密码"

# 代理端口
socks_bind = ":1090"
http_bind = ":1091"

# 非浙大人员请将以下两项置为 true 以避免冲突
disable_zju_config = true
disable_zju_dns = true

dns_ttl = 3600
disable_keep_alive = false
zju_dns_server = "auto"
secondary_dns_server = "114.114.114.114"
debug_dump = false

port_forwarding = []
custom_dns = []

# aTrust 设置
auth_type = "auth/psw"
login_domain = "BMD"

client_data_file = "client_data.json"
graph_code_file = "graph_code.jpg"
update_best_nodes_interval = 300

关于上述配置文件中的 aTrust 设置，需要根据实际情况进行配置。具体来说，当启动 zju-connect 后，终端显示如下：

❯ .\zju-connect.exe -config .\config.toml
2026/02/22 09:58:02 Start ZJU Connect v1.0.0-beta.4-b593140
2026/02/22 09:58:02 Read client data file error: open client_data.json: The system cannot find the file specified.
2026/02/22 09:58:02 Will create a new client data file if log in successfully
2026/02/22 09:58:02 VPN protocol: atrust
2026/02/22 09:58:02 Perform GET /passport/v1/public/authConfig
# --------------注意这一行-----------------
2026/02/22 09:58:02 Available authentication methods: [{LoginDomain:BMD AuthType:auth/psw AuthName:师生用户 LoginURL:} {LoginDomain:local AuthType:auth/psw AuthName:非师生用户 LoginURL:}]
# ------------------------------
2026/02/22 09:58:02 Login error: auth type/login domain combination not found: auth type: auth/psw, login domain: Radius
2026/02/22 09:58:02 VPN client setup error: auth type/login domain combination not found: auth type: auth/psw, login domain: Radius

首次启动失败后的日志中会显示 Available authentication methods，将其中的 LoginDomain 和 AuthType 分别对应地写入 toml 配置文件中即可。然后重新启动 zju-connect 即可。

代理配置

[!note] 此处以 clash 系列为例，v2ray 等其他代理内核的原理一致。

根据上述配置文件中设置的代理端口，需要给 clash 添加新的代理节点、策略组和分流规则。

# 代理端口
socks_bind = ":1090"
http_bind = ":1091"

clash 配置文件变动如下：

# 注意: 新增的分流规则添加在顶部
rules:
  # vpn 地址保持直连
  - DOMAIN,vpn.nmu.edu.cn,🎯 全球直连
  # 内网域名和IP段走策略组
  - DOMAIN-SUFFIX,nmu.edu.cn,🏫 校园网
  - IP-CIDR,10.0.0.0/8,🏫 校园网,no-resolve
  - IP-CIDR,172.16.0.0/12,🏫 校园网,no-resolve

proxies:
- name: zju-local
  type: socks5
  server: 127.0.0.1
  port: 1090
  udp: true
  
proxy-groups:
  - type: select
    name: 🏫 校园网
    proxies:
      - 🚀 节点选择
      - 🎯 全球直连
      - zju-local
      - DIRECT
  # 学术科研的策略组根据实际情况添加
  # 我这里是因为对文献库做了分流
  - type: select
    name: 📚 学术科研
    proxies:
      - 🚀 节点选择
      - 🎯 全球直连
      - 🏫 校园网
      - DIRECT

[!warning] 出于特殊原因，我无需使用脚本完成配置文件修改，因此本文不提供 clash 桌面端的脚本。

journalctl -u ssh

如果在日志中看到了大量的不明 IP 地址在进行尝试，就说明有人在尝试爆破了。

安装 Fail2Ban

在基于 Debian/Ubuntu 的系统中执行：

sudo apt update
sudo apt install fail2ban -y

在基于 RHEL/CentOS 的系统中执行：

sudo yum install epel-release
sudo yum install fail2ban -y

配置文件管理原则

Fail2Ban 默认配置文件为 /etc/fail2ban/jail.conf。为防止软件更新覆盖配置，禁止直接修改该文件。所有自定义配置应写入 /etc/fail2ban/jail.local。

创建并编辑配置文件：

sudo touch /etc/fail2ban/jail.local
sudo nano /etc/fail2ban/jail.local

标准配置方案

将以下内容写入 /etc/fail2ban/jail.local：

[DEFAULT]
# 基础封禁参数
bantime  = 24h
findtime = 1h
maxretry = 3

# 启用阶梯式封禁（针对多次被封禁的 IP 延长封禁时间）
bantime.increment = true
bantime.factor = 1
bantime.maxtime = 5w

# 指定防火墙后端（推荐使用 nftables）
banaction = nftables-multiport
backend = systemd

[sshd]
enabled = true
# 指定实际使用的 SSH 端口
port    = 4399
# 开启激进模式以捕获协议错误、预认证阶段断开等恶意探测
filter  = sshd[mode=aggressive]

关键参数说明

• mode = aggressive：此模式不仅监控密码失败，还会监控密钥交换失败（kex_protocol_error）、连接重置（Connection reset by... [preauth]）等行为。适用于已禁用密码登录、仅使用证书登录的服务器。
• bantime.increment：开启后，如果同一 IP 重复触发封禁，封禁时间将按指数级增长，最高可达 bantime.maxtime。
• findtime = 1h：将监控窗口延长至 1 小时，用于捕获低频尝试的扫描脚本。

服务管理命令

启动与重新加载

# 启动服务并设置开机自启
sudo systemctl enable --now fail2ban

# 每次修改 jail.local 后重新加载配置
sudo systemctl restart fail2ban

查看状态

# 查看 Fail2Ban 整体运行状态
fail2ban-client status

# 查看 SSH 监狱的具体封禁列表和统计
fail2ban-client status sshd

验证配置生效情况

# 查询当前 sshd 监狱生效的 maxretry 值
fail2ban-client get sshd maxretry

# 查询当前 sshd 监狱生效的模式
fail2ban-client get sshd filter

手动操作

# 手动封禁一个 IP
fail2ban-client set sshd banip <IP地址>

# 手动解封一个 IP
fail2ban-client set sshd unbanip <IP地址>

日志监控

通过查看日志确认 Fail2Ban 是否正常识别并过滤恶意请求：

# 查看 Fail2Ban 运行日志
sudo tail -f /var/log/fail2ban.log

# 查看 SSH 登录尝试日志
sudo journalctl -u ssh -f

CDN 或者全站加速等场景，可以设置 HTTP 回源，然后配合 IP 地址列表，实现仅允许对应 IP 访问源站，阻断非法访问。

EdgeOne

[!info] 免费版不支持控制台操作，所以这里借助脚本 + API

nginx 配置如下：

server {
    # default_server 表示如果有其他域名指向这个IP，也都由这个配置处理
    # 只要IP白名单通过，这里就无脑响应
    listen 80 default_server; 
    
    # _ 是一个常见的习惯用法，代表“匹配所有域名”或“不关心域名”
    server_name _; 

    root /var/www/files;

    # 引入之前的 IP 白名单脚本生成的配置文件
    include /etc/nginx/edgeone_ips.conf;

    location / {
        autoindex on;
    }
}

编写更新脚本 /usr/local/bin/update_edgeone_ips.sh：

#!/bin/bash

# 定义文件路径
API_URL="https://api.edgeone.ai/ips"
CONF_FILE="/etc/nginx/edgeone_ips.conf"
TEMP_FILE="/tmp/edgeone_ips.tmp"

echo "1. 开始下载 IP 列表..."
# --http1.1: 强制使用旧协议，防止卡死
# -s: 静默模式 (不显示进度条)
# -S: 如果报错则显示错误信息
curl -sS --http1.1 "$API_URL" > "$TEMP_FILE"

# 检查是否下载到了内容（文件是否存在且大小大于 0）
if [ ! -s "$TEMP_FILE" ]; then
    echo "❌ 下载失败：文件为空。"
    exit 1
fi

echo "2. 格式化并生成 Nginx 配置..."
# 使用 awk 提取非空行的第一列，拼接成 allow 语句
awk 'NF {print "allow " $1 ";"}' "$TEMP_FILE" > "$CONF_FILE"

# 追加 deny all
echo "" >> "$CONF_FILE"
echo "deny all;" >> "$CONF_FILE"

echo "3. 重载 Nginx..."
# 检查配置无误后重载
nginx -t && systemctl reload nginx

echo "✅ 完成！"
# 清理临时文件
rm -f "$TEMP_FILE"

赋予执行权限后，设置定时任务：

0 3 */3 * * /usr/local/bin/update_edgeone_ips.sh

curl -fsSL https://pixi.sh/install.sh | sh

上述调用将自动下载最新版本的 pixi 并解压，然后将 pixi 二进制文件移动到 ~/.pixi/bin 。该脚本还会扩展 shell 启动脚本中的 PATH 环境变量，使其包含 ~/.pixi/bin 。

完成后可添加 shell 自动补全：

# bash
eval "$(pixi completion --shell bash)"

# zsh
autoload -Uz compinit && compinit # redundant with Oh My Zsh
eval "$(pixi completion --shell zsh)"

# powershell
(& pixi completion --shell powershell) | Out-String | Invoke-Expression

初始化

• 如果是新建项目，可执行 pixi init project_name
• 如果是已有的项目，可执行 pixi init

两者都会在项目路径下生成 .gitattributes，.gitignore，pixi.lock 和 pixi.toml。

安装与卸载包

可通过 add 命令添加包：

pixi add python=3.10

默认情况下，pixi 会使用 conda-forge 作为安装渠道。对于只提供 pypi 渠道的包，可以通过：

pixi add xxx --pypi

上述操作均会更新 pixi.toml，在 dependencies 表中添加键值对，例如：

[dependencies]
python = "3.10.*"
rasterio = ">=1.4.3,<2"
nvitop = ">=1.5.3,<2"

卸载通过如下方式：

pixi remove numpy

环境与激活

需要声明的是，在 pixi 中，每个项目的环境都是独立的，依赖于配置文件。但包本身只会被下载一次，并缓存在中央存储中，所有项目的环境通过硬链接产生，存储在工作区下的 .pixi 中。区别于 conda，pixi 支持对于同一个项目产生不同的环境。默认的环境为 .pixi/envs/default。

类似于 conda activate ，pixi 通过 pixi shell 来激活当前环境，这取决于在哪个工作区下的 pixi.toml。

当然，也可以选择不激活环境，而是直接通过 pixi run python xxx 来执行任务。

更多的区别，推荐阅读 官方文档，这一节很清楚的讲明了 pixi 的工作方式去其他工具有何不同。

缓存

pixi 会将下载的所有包存储在中央缓存中，不同操作系统对应的路径如下：

• Linux： $XDG_CACHE_HOME/rattler 或 $HOME/.cache/rattler
• macOS: $HOME/Library/Caches/rattler
• Windows: %LOCALAPPDATA%\rattler

而工作区中的 .pixi 里的包通过硬链接共享中央缓存。可以通过设置 PIXI_CACHE_DIR 或 RATTLER_CACHE_DIR 环境变量来配置此位置。

pixi 配置

官方文档

配置文件

pixi 的配置与工作区的配置是两个东西。pixi 的配置优先级可参考 The Configuration of Pixi Itself。

简单来说，通常情况下在 $HOME/.pixi/config.toml 中添加 pixi 配置即可，可保证相对较高的优先级且与工作区配置解耦。

镜像与代理

先说代理的问题，pixi 会优先考虑 https_proxy 等代理环境，并赋予其最高优先级。所以建议直接配置即可。

pixi 的常用镜像包括 pypi 和 conda 两部分，config.toml 的配置方式如下：

[mirrors]
"https://conda.anaconda.org/conda-forge" = [
  "https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/conda-forge/",
]
"https://repo.anaconda.com/pkgs/main" = [
  "https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main/",
  "https://mirrors.ustc.edu.cn/anaconda/pkgs/main",
]
"https://repo.anaconda.com/pkgs/r" = [
  "https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/r",
  "https://mirrors.ustc.edu.cn/anaconda/pkgs/r",
]
"https://repo.anaconda.com/pkgs/msys2" = [
  "https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/msys2",
  "https://mirrors.ustc.edu.cn/anaconda/pkgs/msys2",
]
"https://repo.anaconda.com/pkgs/free" = [
  "https://mirrors.sustech.edu.cn/anaconda/pkgs/free"
]
"https://repo.anaconda.com/pkgs/pro" = [
  "https://mirrors.sustech.edu.cn/anaconda/pkgs/pro"
]


[pypi-config]
index-url = "https://mirrors.aliyun.com/pypi/simple"
extra-index-urls = ["https://pypi.tuna.tsinghua.edu.cn/simple"]

由于 Pytorch 官方已不再对 Anaconda 的 pytorch channel 提供支持，因此上述镜像没有添加清华与南科大的 pytorch/nvidia 渠道。

系统需求

system-requirements 可以告诉 pixi 安装和运行工作区环境所需的系统规格。确保依赖项与计算机的操作系统和硬件相匹配。

[system-requirements]
linux  = "4.18"
libc   = { family = "glibc", version = "2.28" }
cuda   = "12"
macos  = "13.0"

默认情况下，Linux 环境的系统需求如下：

[system-requirements]
linux = "4.18"
libc = { family = "glibc", version = "2.28" }

所以如果使用 Ubuntu 18.04 等 old distribution，注意修改 libc 的版本。

Pytorch 的安装

官方文档

官方建议使用 conda-forge 通道来安装 pytorch。至于 Anaconda 的 pytorch 渠道，目前不再支持，参考 Deprecating PyTorch’s official Anaconda channel。当然，使用 pypi 来安装 pytorch 永远是可行的。

需要注意的是，pixi 安装 pytorch 时，需要指定 system requirements（即 CUDA），否则将安装 CPU 版本：

[system-requirements]
cuda = "11"

[!warning] system-requirements 仅用于确保依赖 __cuda >= {version} 的软件包能够被正确解析，但无法指定特定的 CUDA 运行时版本。

如果需要限制 CUDA 的具体版本，可以通过 cuda-version 包来限制：

[dependencies]
pytorch-gpu = "2.0.0"
cuda-version = "11.8"

这会直接影响安装的 cudatoolkit 的版本。

将上述内容添加到工作区的 pixi.toml 后，使用 pixi install 即可更新环境依赖。

多环境

在 pixi 中，有三个层级概念：environment > feature > dependencies。dependencies 表示依赖包，若干个依赖包可以形成一个 feature，若干个 feature 可以组合成一个 environment。

项目初始化所产生的 .pixi/envs/default 本身就是一个名为 default 的 feature，换言之：

# 根据feature创建环境

[environments]
# implicit: default = ["default"]
default = ["py39"] # implicit: default = ["py39", "default"]

如果需要创建一个新的 feature，可通过：

pixi add --feature dev --pypi matplotlib==3.8 ipykernel

即创建了一个名为 dev 的 feature，其具有两个 dependencies：matplotlib 和 ipykernel。这会在 pixi.toml 中添加如下内容：

[feature.dev.pypi-dependencies]
matplotlib = "==3.8"
ipykernel = "*"

基于上述过程，可以将若干个 feature 组合成一个 environment：

[environments]
dev = {features = ["default", "dev"]}

然后执行 pixi install -e dev 即可创建新的环境。其中 dev 环境包含了 default feature 中的所有 dependencies，还额外具有 matplotlib 和 ipykernel 两个包。

solve-group

当 pixi 解析依赖关系时，它会为每个独立的环境计算出一组满足所有版本约束的、具体的包版本，并将结果写入 pixi.lock 文件。通常情况下，每个环境的解析是独立进行的。

然而，在某些情况下，不同环境之间可能会因为各自特有的依赖而导致解析器为同一个共享依赖选择了不同的版本。这在生产/测试环境下可能是个问题。solve-group 的可以确保多个不同环境中的共享依赖包版本完全一致。通过将多个环境放入同一个 solve-group，等于在告诉 Pixi：“请把这些环境看作一个整体来解析它们的依赖关系，并确保它们共有的那些包版本是完全相同的。”

[environments]
# 为 default 环境和 dev 环境定义 solve-group
default = {features = ["default"], solve-group = "prod"}
dev = {features = ["default", "dev"], solve-group = "prod"}

[!Tip] 学业生涯的最后一篇论文笔记。你与我最后的战场，亦或是世界起始的圣战。

引言

推荐系统的主要功能是预测用户对各种项目的评分或偏好，并根据历史交互数据和公开信息推荐最可能和最相关的项目。然而，传统的基于 ID 的推荐方法基于用户倾向于选择与他们以前喜欢的项目类似的项目的原则，通常强烈依赖于足够的用户项目交互。尽管取得了成功，推荐系统仍面临两大挑战：数据稀疏性和冷启动问题。数据稀疏性源于用户和产品之间交互数据的自然稀疏性，这使得准确预测用户的偏好变得困难。这种稀疏性可能会导致不可靠的推荐，特别是在商品目录较大但用户交互相对较少的系统中。冷启动问题的发生是因为传统的推荐系统模型严重依赖 ID 嵌入，在几乎没有历史交互数据的情况下，很难对新用户或产品做出令人满意的预测。在不断引入新项目和用户的动态环境中，这一挑战尤为明显。

为了缓解这些问题，多模式信息正越来越多地被整合到推荐系统中。MRS 利用辅助多模式信息，如文本、图像、视频和音频，来补充用户和项目之间的历史交互。这种方法通过更丰富、更全面地了解用户偏好来提高推荐性能。推荐系统的基本目标是迎合人们的偏好，由于人类对世界的感知本质上是多模态的，因此结合不同的模态信息可以在更精细的粒度上捕捉偏好。这导致了更准确和个性化的推荐，从而提高了用户满意度和参与度。

技术分类

基于对当前 SOTA MRS 工作的总结和组织，将 MRS 中的技术分为四个部分：特征提取、编码器、多模态融合和损失函数。

特征提取

不同的应用场景包含不同类型的模态信息，导致具有不同多模态特征的不同数据集。然而，大多数数据集至少包括三种主要模式：交互、视觉和文本。例如，亚马逊、Netflix 和 TikTok 等大型平台提供了丰富的图像和文本信息数据集，从而涵盖了视觉和文本形式。具体来说，TikTok 数据集通常包括其他模式，如音频和视频。此外，来自专业领域的数据集有时具有罕见的模式。例如，时尚和医疗保健等热门领域的数据集通常包括各种专业模式。

特征提取是一个关键过程，旨在使用嵌入技术表示低维、可解释的信道特征。不同的模态采用不同的预提取方法。对于视觉模态，使用 ResNet 和 ViT 等模型来提取特征。在文本模态的情况下，使用 BERT 和 Sentence-Transformer 等模型来推导特征。音频特征通常使用 LSTM 和 GRU 等模型提取。

编码器

编码器利用从多模态信息和历史交互数据中提取的特征来推断用户偏好表示，随后用于预测用户 - 项目交互以进行推荐。与传统的推荐系统类似，用于多模态推荐的编码器可以大致分为基于矩阵分解（MF）和基于图卷积网络（Graph）的方法。基于 MF-based 的方法以其简单性和有效性而闻名，而基于图的方法利用用户项目交互中固有的二分图来学习高阶邻居特征。

随着 MRS 的快速发展，人们提出并利用了更复杂的编码器来充分利用丰富的多模态信息，从而提高了推荐性能。这些先进的编码器能够集成各种多模态数据，从而提供更准确和个性化的建议。

多模态融合

多模态融合是 MRS 的重点之一。最近的研究表明，模态融合的时机会显著影响建议的有效性。多模态融合涉及在不同阶段整合来自不同模态的信息，而这个时机对于实现最佳性能至关重要。

• Early Fusion： 早期融合涉及在编码器处理之前组合不同的模态特征。这种方法可以有效地揭示模态之间的隐藏关系，因为集成的多模态特征允许编码器学习更丰富、更高质量的表示。早期融合可以捕捉不同类型数据（如文本、图像和音频）之间的复杂交互，从而更全面地了解用户偏好。早期融合技术通常包括连接、注意力机制和基于神经网络的集成方法，旨在创建多模态数据的统一表示。
• Late Fusion： 后期融合在单个模态特定编码器处理后，将每种模态的分数或预测结合起来。这种方法侧重于利用每种特定模态模型的优势，然后结合它们的输出来做出最终建议。在某些模式比其他模式更有信息或更可靠的情况下，后期融合可能特别有效。通过将融合过程推迟到预测阶段之后，后期融合允许更有针对性和更精确地提取特定的模态信息，从而提高了整体推荐的准确性。

后期融合好像还挺少见的？

损失函数

MRS 利用损失函数，损失函数可大致分为两个部分：主要任务和辅助任务。主要任务是监督学习，通常涉及明确定义的标签来指导模型的学习过程。这些任务确保模型能够根据标记的数据学习做出准确的预测。辅助任务是自监督学习（SSL）。SSL 根据数据本身的固有结构或模式生成监督信号，而不是仅依赖外部标记的数据。这种方法允许推荐系统有效地利用未标记的数据，提取有意义的表示，即使在数据稀疏的情况下也能做出准确的预测。

监督学习可以进一步细分为逐点损失（Pointwise Loss）和成对损失（Pairwise Loss）。

• Pointwise Loss：此损失是通过将每个单独项目的预测得分与其实际标签进行比较来计算的。常见的逐点损失函数包括均方误差（MSE）和交叉熵损失（CE），用于直接评估单个预测的准确性。
• Pairwise Loss：这种损失集中在项目的相对排名上。它评估模型根据用户偏好正确排序每对项目的能力。常见的成对损失函数包括贝叶斯个性化排名（BPR）和 Hinge Loss，旨在优化项目的排名顺序，而不是其绝对得分。

自监督学习可分为基于特征和基于结构的方法。

• Feature-based SSL：这种方法涉及创建辅助任务来预测或重建数据的某些特征。例如，可以训练模型以基于可用数据预测项目或用户的缺失特征，从而学习更稳健的表示。
• Structure-based SSL：这种方法利用了数据的结构属性，例如用户和项目之间的关系和交互。例如，基于图的方法可能会使用节点相似性或子图模式来生成监督信号，从而增强模型捕获复杂依赖关系和交互的能力。

特征提取

在视觉领域，早期的研究主要利用卷积架构，如 CNN，以及 VGG、Inception、Caffe 和 ResNet 等特定模型，这些模型在处理各种视觉识别任务方面表现出了显著的有效性。这些模型因其深度学习能力而备受推崇，该能力允许从原始图像中提取高级、复杂的特征。此外，在文本领域，已经采用了多种技术进行特征提取。这些方法包括 TF-IDF 等传统方法，以及 GRU、PV-DM（PV-DBOW）和 Glove 等更复杂的神经网络方法。注意力机制的引入，以及 BERT、Word2Vec、Sentence-Transformer 和 Sentence2Vec 等模型，通过允许上下文丰富的文本表示，进一步彻底改变了理解和处理语言的能力。

随着该领域的发展，MMRec 开源框架 通过标准化视觉和文本模式的特征提取方法来体现这一趋势，从而促进了更可控和可重复的实验设置。此外，数据质量也带来了挑战，例如亚马逊数据集中的一些损坏和缺失的图像。因此，最近的方法已经转向利用视觉模态中预先提供的特征来规避与手动处理相关的问题。同样，在文本模态中，对预训练模型的依赖已经变得司空见惯。这些模型为特征提取提供了坚实的基础，利用大量预先存在的知识库来提高文本分析的准确性和深度。

此外，并非所有研究都全面涉及视觉和文本模式。一些作品主要关注视觉方面作为辅助信息的一种形式。例如，VBPR 和 DVBPR 强调了视觉特征在增强推荐系统中的重要性，而忽略了文本数据。同样，VMCF 和 ACF 结合了视觉信息来提高其模型的准确性，但它们没有整合文本见解，而文本见解可能会丰富对数据的上下文理解。在对抗方面，AMR 利用视觉模态来增强其模型对对抗攻击的鲁棒性，但文本模态仍未得到探索。相反，ADDVAE 只关注文本形态，从而提供了对文本数据的细致入微的理解，但省略了视觉信息丰富的描述性。

编码器

在推荐系统中，编码器通常用于提取用户或项目的特征表示。编码器可以是多种类型的模型，从简单的线性模型到复杂的深度神经网络。主要目的是将原始数据（如用户行为数据、项目属性等）转换为固定大小的嵌入，以捕获输入数据的核心特征。然而，在多模态推荐中，编码器起着相同的作用，但由于特征的多样性，已经提出了更多样化和专门设计的编码器，以更好地利用多模态信息和用户交互数据进行更准确的推荐。从技术角度来看，我们将所有编码器大致分为 MF-based 编码器和 Graph-based 编码器。

定义 1：设用户集合 $\mathcal{U} \in \mathbb{R}^{|\mathcal{U}| \times d}$ 和物品集合 $\mathcal{I} \in \mathbb{R}^{|\mathcal{I}| \times d}$，其中 $d$ 是隐藏维度。我们用 $\mathbf{R} = [r_{u,i}]^{|\mathcal{U}| \times |\mathcal{I}|}$ 来表示用户 - 物品交互矩阵。对于基于图的编码器 $\mathcal{G} = (\mathcal{V}, \mathcal{E})$，它是一个给定的图，节点集为 $\mathcal{V}$，边集为 $\mathcal{E}$，其中 $|\mathcal{V}| = |\mathcal{U}| + |\mathcal{I}|$。$\mathbf{U}$ 和 $\mathbf{I}$ 分别表示用户和物品的隐藏嵌入。$\mathbf{E} = {\mathbf{U}|\mathbf{I}}$ 表示 $\mathcal{V}$ 的嵌入。

定义 2：重述项目集 $\mathcal{I}_m \in \mathbb{R}^{|\mathcal{I}| \times d_m}$，其中 $m \in \mathcal{M}$，$\mathcal{M}$ 是模态集合，$d_m$ 是模态 $m$ 的隐藏维度。此外，$\mathcal{G}_m = (\mathcal{V}m, \mathcal{E})$ 是一个给定的图，节点集 $\nu{m}$ 和边集 $\mathcal{E}$，其中 $|\mathcal{V}_m| = |\mathcal{U}| + |\mathcal{I}_m|$。$\mathbf{I}_m$ 表示模态 $m$ 的项目隐藏嵌入。$\mathbf{E}_m = {\mathbf{U}|\mathbf{I}m}$ 表示 $\nu{m}$ 的嵌入。

MF-based Encoder

基于 MF 的编码器的核心思想是将用户项目评级矩阵 R 分解为两个低阶隐藏嵌入 U 和 I。评分矩阵 R 的近似值可以表示为： $$ \mathbf{R}\approx \hat{\mathbf{R}} = \mathbf{U}\mathbf{I}^T, \tag{1} $$

损失函数可以定义为： $$ \min_{\mathbf{U},\mathbf{I}}| \mathbf{R} - \hat{\mathbf{R}}| _F^2 +\lambda (| \mathbf{E}| _F^2), \tag{2} $$

由于该项目的多样化特征，粗略地说，MRS 的评级矩阵 R 的近似值可以表示为： $$ \begin{array}{r}\mathbf{R}\approx \hat{\mathbf{R}} = \mathbf{U}\mathbf{I}^T,\quad \mathbf{I} = \mathrm{Aggr}(\mathbf{I}_m),\ \mathbf{R}\approx \hat{\mathbf{R}} = \mathrm{Aggr}(\mathbf{U}\mathbf{I}_m^T), \end{array} \tag{3} $$

其中 Aggr（·）表示多模态融合。损失函数可以定义为： $$ \min_{\mathbf{U},\mathbf{I}}| \mathbf{R} - \hat{\mathbf{R}}| F^2 +\lambda (\sum{m\in M}| \mathbf{E}_m| _F^2). \tag{5} $$

[!tip] 所以说，矩阵分解的 MRS 是让分解后的评分矩阵和原始评分矩阵尽可能相似。至于多模态，就是不同的融合方式而已。

Graph-based Encoder

图基编码器的核心思想是利用节点的特征和图的结构信息来学习节点的表示。我们介绍常用的图基编码器范式图卷积网络（GCN）。对于一个图 $\mathcal{G}$ 及其邻接矩阵 $\mathbf{A}$，GCN 的一层传播可以表示为： $$ \mathbf{E}^{(l)} = \sigma (\tilde{\mathbf{D}}^{-\frac{1}{2}}\tilde{\mathbf{A}}\tilde{\mathbf{D}}^{-\frac{1}{2}}\mathbf{E}^{(l - 1)}\mathbf{W}^{(l - 1)}), \tag{6} $$ 其中 $\mathbf{E}^{(l)}$ 是 $\mathcal{V}$ 的第 $l$ 层隐藏嵌入，$\tilde{\mathbf{A}} = \mathbf{A} + \mathbf{I}$。$\tilde{\mathbf{D}}$ 是 $\tilde{\mathbf{A}}$ 的度矩阵，其中 $\tilde{\mathbf{D}}{ii} = \sum{j}\tilde{\mathbf{A}}{ij}$。$\mathbf{W}^{(l - 1)}$ 是第 $l - 1$ 层的权重矩阵，$\sigma (\cdot)$ 是激活函数。在推荐领域，LightGCN 证明了 GCN 中的权重矩阵和激活函数是无用的，甚至增加了训练难度。为此，广泛使用的简化 GCN 可以表示为： $$ \mathbf{E}^{(l)} = \tilde{\mathbf{D}}^{-\frac{1}{2}}\tilde{\mathbf{A}}\tilde{\mathbf{D}}^{-\frac{1}{2}}\mathbf{E}^{(l - 1)}, \tag{7} $$ 然后它通过 $\tilde{\mathbf{E}} = \mathrm{Stack}{l\in L}(\mathbf{E}^{(l)})$ 堆叠多个层，其中 $L$ 是 GCN 的总层数。我们简单地将整个基于图的编码器定义为 $\tilde{\mathbf{E}} = \mathrm{GCN}(\mathbf{U},\mathbf{I})$ 。整个表示 $\tilde{\mathbf{E}}$ 可以通过 $\tilde{\mathbf{U}},\tilde{\mathbf{I}} = \mathrm{Sp}(\tilde{\mathbf{E}})$ 分成用户和项目部分。为了更好地挖掘用户和项目表示，提出了两种同构类型图，用户 - 用户和项目 - 项目。一部分基于图的编码器将使用其中一个或全部来更好地学习表示。同构图首先按相似性保留前 $k$ 个项目/用户： $$ \begin{array}{r}\mathbf{S}{i,i^{\prime}}^{I} = \left{ \begin{array}{ll}1, & \mathbf{S}{i,i^{\prime}}^{I}\in \mathrm{top - }k(\mathbf{S}{i,i^{\prime}}^{I}),\ 0, & \mathrm{otherwise} \end{array} \right., \ \mathbf{S}{u,u^{\prime}}^{U} = \left{ \begin{array}{ll}1, & \mathbf{S}{u,u^{\prime}}^{U}\in \mathrm{top - }k(\mathbf{S}{u,u^{\prime}}^{U}),\ 0, & \mathrm{otherwise} \end{array} \right.. \end{array} \tag{8-9} $$

为缓解图结构数据中高阶顶点与低阶顶点之间特征分布的显著差异问题，通常对邻接矩阵应用对称归一化，表示为 $\mathbf{S}^{U} = (\mathbf{D}^{U})^{- 1 / 2}\mathbf{S}^{U}(\mathbf{D}^{U})^{- 1 / 2}$ 和 $\mathbf{S}^{I} = (\mathbf{D}^{I})^{- 1 / 2}\mathbf{S}^{I}(\mathbf{D}^{I})^{- 1 / 2}$，其中 $\mathbf{D}^{U}$ 和 $\mathbf{D}^{I}$ 分别表示 $\mathbf{S}^{U}$ 和 $\mathbf{S}^{I}$ 的对角度矩阵。此归一化过程至关重要，因为它根据每个顶点的连通性调整其影响，从而防止高阶顶点在特征表示中占据不成比例的优势。然后通过传播 $\tilde{\mathbf{U}} /\tilde{\mathbf{I}}$：

$$ \begin{array}{r}\hat{\mathbf{U}} = (\mathbf{S}^U)^{L_u}\bar{\mathbf{U}},\hat{\mathbf{I}} = (\mathbf{S}^I)^{L_i}\bar{\mathbf{I}}, \end{array} \tag{10} $$ 其中 $L_{u}$ 和 $L_{i}$ 分别是用户-用户图和物品-物品图的层数。这两种表示可以通过 $\tilde{\mathbf{U}} = \tilde{\mathbf{U}} +\tilde{\mathbf{U}}$ 和 $\tilde{\mathbf{I}} = \hat{\mathbf{I}} +\bar{\mathbf{I}}$ 可选地增强用户和物品表示。

为简化起见，我们将包含可选用户-用户和物品-物品图的复合图编码器定义为： $$ \tilde{\mathbf{U}},\tilde{\mathbf{I}} = \mathrm{C - GCN}(\mathbf{U},\mathbf{I})) \tag{11} $$

MRS的评分矩阵 $\mathbf{R}$ 的近似可以表示为： $$ \mathbf{R}\approx \hat{\mathbf{R}} = \tilde{\mathbf{U}}\tilde{\mathbf{I}}^T,\quad \tilde{\mathbf{U}},\tilde{\mathbf{I}} = \mathrm{C - GCN}(\mathbf{U},\mathbf{I})). \tag{12} $$

损失函数可以定义为公式1。粗略地说，MRS的评分矩阵 $\mathbf{R}$ 的近似可以表示为： $$ \begin{array}{r}\mathbf{R}\approx \hat{\mathbf{R}} = \tilde{\mathbf{U}}\tilde{\mathbf{I}}^T,\quad \tilde{\mathbf{U}},\tilde{\mathbf{I}} = \mathrm{C - GCN}(\mathbf{U},\mathrm{Aggr}(\mathbf{I}_m)),\ \mathbf{R}\approx \hat{\mathbf{R}} = \mathrm{Aggr}(\tilde{\mathbf{U}}\tilde{\mathbf{I}}_m^T),\quad \tilde{\mathbf{U}},\tilde{\mathbf{I}}_m = \mathrm{C - GCN}(\mathbf{U},\mathbf{I}_m). \end{array} \tag{13} $$

多模态融合

多模态融合是MRS中的一个关键研究领域。多模态整合的效果在很大程度上受到不同模态融合时间以及用于执行这种融合的策略的影响。因此，基于这两个视角：时间与策略，对现有工作进行系统分析和分类变得至关重要。

时间

我们首先从时间角度对MRS中的所有近期工作进行分类。具体来说，可以分为早期融合和晚期融合策略。形式上， $$ \mathbf{E} = \mathrm{Encoder}(\mathbf{U},\mathrm{Aggr}(\mathbf{I}_m)), \tag{15} $$ $$ \mathbf{\bar{E}} = \mathrm{Aggr}(\mathrm{Encoder}(\mathbf{U},\mathbf{I}_m)), \tag{16} $$ 早期融合表示在图消息传播和聚合之前融合所有模态。晚期融合表示在图消息传播和聚合之后融合所有模态。尽管早期和晚期融合时机在各种场景中都表现出色，但每种方法都表现出不同的局限性。具体来说，早期融合倾向于在早期阶段整合模态，这可能导致模态特定特征未能被充分挖掘，因为过早整合。另一方面，后期融合策略在较晚阶段结合模态，面临充分捕捉和利用不同模态之间相关性的挑战。这可能会限制模型提取不同模态之间相关性的能力，从而可能降低利用多模态信息的整体效果。

[!note] 其实还有一个问题，如果模型计算比较复杂，早期融合的效率会比晚期融合高很多。因为现“融成一坨”之后，你就只需要对这一个 tensor 做计算，否则你需要对每个模态分别处理，即复杂度线性增加（取决于模态数量）。

策略

从策略角度看，所有近期的工作可以从两个维度进行细粒度分类，即逐元素或拼接以及注意力或启发式。MRS中的许多工作都对融合策略进行了细微调整。尽管存在这些变化，但可以根据推动其使用的潜在动机，以一种广泛的方式对这些方法进行分类，如表IV所述。

元素级融合方法相比拼接方法提供了更深入的不同模态整合。然而，这种更深层次的整合可能会无意中放大模态数据中存在的固有噪声。另一方面，注意力方法相比于启发式方法，提供了更动态的模态权重分配，使得可以根据输入特征与特定任务的相关性，更适应性和响应性地处理输入特征。尽管有其优势，但注意力机制会显著增加计算成本，并增加训练阶段的复杂性。

融合策略通常与融合时机协同作用，从而显著影响模型性能。认识到这种相互作用，我们对MRS中的近期融合策略和时机进行了全面总结，如图5所示。我们的目标是为研究人员提供一个更清晰的视角，了解这些观点如何共同作用以影响模型性能。

啧，要不说高手写的论文就是 8 一样呢。两个不同的 entity tensor 要么加要么拼，要么加权之后再加/再拼。硬是能单开出一节 Strategy 来写，6

分类法

Taxonomy 在论文的每一章都进行了分类，就是字面意义上的归个类，然后简要的写几笔。有需要的可以看下原文。这里只放一个模型时序的分类图足以。

话又说回来了，22 年以后基本就很少见到矩阵分解的做法了，大多都是基于 GCN 的。猜测可能是 MF 对数学理论功底要求比较高，想水还真不太好水，GCN 就不一样了。。。

损失函数

MRS使用由两个关键类型组成的损失函数：主要任务和辅助任务，如图7所示。主要任务涉及监督学习，其中明确的标签指导模型的学习，确保从标记数据中进行准确预测。相反，辅助任务采用自监督学习（SSL），它从数据的内在结构生成监督信号，而无需外部标签。这种方法能够有效利用未标记的数据，使系统即使在标记数据稀疏的情况下也能提取有意义的表示并保持准确性。我们详细介绍了这两种类型的损失函数。

监督学习

初步：在RS场景中，我们将推荐模型简化定义为 $f(\cdot)$ ，它可以通过以下方式预测用户 $u$ 和物品 $i$ 之间的评分： $$ y_{u,i} = f(\mathbf{R},u,i), \tag{17} $$ 其中 $\mathbf{R} = [r_{u,i}]^{|U|\times |Z|}$ 表示用户-物品交互矩阵。在MRS场景中，多模态推荐模型将扩展为 $f_{m}(\cdot)$ ，它可以通过多模态信息预测用户 $u$ 和物品 $i$ 之间的评分： $$ y_{u,i} = f_{m}(\mathbf{R},u,i,\mathbf{M}), \tag{18} $$

监督学习任务是将任何用户 $u$ 和项目 $i$ 之间的预测得分拉近到真实标签。它可以分为点损失和成对损失。

对于逐点损失，我们引入了两种常见的损失函数，这些函数在许多机器学习下游任务中也被广泛使用，例如计算机视觉和自然语言处理。1）均方误差（MSE） 和 2）交叉熵损失（CE）。

MSE可以定义为： $$ \frac{1}{|\mathcal{D}|}\sum_{(u,i)\in \mathcal{C}}(r_{u,i} - y_{u,i})^2, \tag{19} $$ 其中 $\mathcal{D}$ 表示训练集。这个损失函数将交互的用户-物品对的预测得分更接近1，非交互的用户-物品对的预测得分更接近0。

CE 可以定义为： $$ -\frac{1}{|\mathcal{D}|}\sum_{(u,i)\in \mathcal{D}}[r_{u,i}\log (y_{u,i}) + (1 - r_{u,i})\log (1 - y_{u,i})]. \tag{20} $$ 在RS（MRS）领域中利用CE，将预测函数视为一个两分类任务，将用户-物品对分类为已交互和未交互类别。这通过最小化预测概率分布与真实标签分布之间的差异来提高分类精度，使模型能够更好地学习分类标签的概率分布。然而，由于用户-物品交互数据的天然稀疏性，我们需要更加重视稀缺的标记数据，因此进一步提出了成对损失。

对于点损失，学习目标是拉近正样本对，同时推开负样本对。我们引入了两种常用的损失函数，它们也是广泛使用的损失函数。1）贝叶斯个性化排序（BPR） 和 2）Hinge 损失。

BPR 可以定义为： $$ \sum_{(u,i^+,i^-)\in \mathcal{D}} - \log (\sigma (y_{u,i^+} - y_{u,i^-})), \tag{21} $$ 其中 $y_{u,i^+}$ 和 $y_{u,i^- }$ 是用户 $u$ 对正样本项 $i^+$ 和负样本项 $i^-$ 的评分。$\sigma$ 是激活函数。

Hinge Loss 可以定义为： $$ \max (0,1 - r_{u,i}\cdot y_{u,i}). \tag{22} $$ Hinge Loss 旨在不仅正确分类数据点，而且最大化分类决策边界的间距。

Hinge Loss? 你还别说，真没见过😅

自监督学习

在 RS 场景中，自监督学习首先为对比学习创建两个不同的视图，我们简单地将这个视图生成器定义为： $$ w = \mathcal{C}(\mathbf{R},\mathbf{E}), \tag{23} $$ 其中 $\mathcal{C}(\cdot)$ 是一个视图创建者。$\mathbf{R}$ 和 $\mathbf{E}$ 使用与第四节相同的定义。在MRS场景中，视图创建者可以进一步定义为 $$ w = \mathcal{C}(\mathbf{R},\mathbf{E},\mathbf{M}). \tag{24} $$

[!warning] 我倒是不否定目前 RS 中的 SSL 基本就是对比学习了，但是直接把自监督特指为对比学习多少还是有点不合适吧。。。

视图创建者可分为两种类型：1）基于特征的SSL和2）基于结构的SSL。

基于特征的SSL旨在通过扰动特征生成同一数据实例的多个视图。这种方法被战略性地用于增强学习表示的鲁棒性。通过在输入特征中引入变化，模型被迫关注这些修改中的不变方面，从而获得对用户-项目交互更深入、更通用的理解。它可以简化表示为： $$ \omega = \mathcal{C}_{feature}(\mathbf{R},\mathbf{E},\mathbf{M}) = (\mathbf{R},\mathrm{Perturb}(\mathbf{E}),\mathbf{M}), \tag{25} $$ 其中 Perturb 可以是 MLP、特征丢弃、添加随机噪声等。值得注意的是，不同的模态可以自然地被视为两种基于特征的视图。对两种不同模态表示应用基于特征的自监督学习可以看作是模态对齐。

基于结构的 SSL旨在通过扰动图结构为同一数据实例生成多个视图。这种方法被用来细致地捕捉图结构中固有的复杂依赖关系和交互作用，这对于提高基于图的学习模型的鲁棒性和性能至关重要。这种操作使学习算法能够从数据的本质特征中辨识并进行泛化，从而在图数据普遍的领域中可能产生更有效和有见地的表示。它可以简化表示为： $$ \omega = \mathcal{C}_{structure}(\mathbf{R},\mathbf{E},\mathbf{M}) = (\mathrm{Perturb}(\mathbf{R}),\mathbf{E},\mathbf{M}), \tag{26} $$ 其中 Perturb $(\cdot)$ 可以是 MLP、节点/边丢弃、添加随机噪声等。

自监督学习任务是强制生成的视图更接近，以增强MRS模型的表示能力。我们引入了两种广泛使用的自监督损失函数。1）InfoNCE 和 2）Jensen- Shannon散度（JS）。

InfoNCE 是噪声对比估计的一种变体，作为推荐系统中的自监督学习损失函数得到了广泛采用。它可以表示为： $$ \mathbb{E}[-\log \frac{\exp(f(\omega_i',\omega_i''))}{\sum_{\forall i,j}\exp(f(\omega_i',\omega_j''))}], \tag{27} $$ 其中 $f(\cdot)$ 表示一个评判函数，用于计算两个视图之间的相似性得分。项 $\exp f(\omega_i',\omega_i'')$ 对应正对的得分，而项 $\sum \exp (f(\omega_i',\omega_j''))$ 包含分子和所有负对的得分。

除了使用InfoNCE估计互信息外，下界也可以通过Jensen-Shannon（JS）散度进行估计。推导出的学习目标类似于将InfoNCE与标准二元交叉熵损失相结合，应用于正样本对和负样本对。 $$ \mathbb{E}[-\log \sigma (f(\omega_i',\omega_i''))] - \mathbb{E}[\log (1 - \sigma (f(\omega_i',\omega_j'')))], \tag{28} $$ 其中σ表示用于归一化判别函数输出的sigmoid函数。这种优化的主要思想是将标签1分配给正样本对，将标签0分配给负样本对，从而提高正样本对的预测值并增强它们之间的相似性。

当用户具有多个 Git 账户时，就会出现 Git 权限的冲突问题。例如 A 账户无法向 B 账户下的仓库提交 commit。为此，可以通过多密钥的方式来解决。

操作步骤

首先为不同的账户创建密钥：

ssh-keygen -t ed25519 -C "sun2ot" -f ~/.ssh/id_ed25519_sun2ot

这里的 -C 用于在密钥中插入注释，用于区分不同的密钥。-f 指定了你要文件的名称和路径。

类似的，可以用 -C "Account of B" 来创建其他账户的密钥。

然后，在 ~/.ssh/config 中添加对应的 SSH 配置：

Host github-sun2ot
  Hostname ssh.github.com
  User git
  Port 443
  IdentityFile ~/.ssh/id_ed25519_sun2ot

这里的 IdentityFile 注意要设置成私钥（即不带 .pub 后缀）。此外，SSH 的默认端口本来是 22，但有的时候由于代理或者防火墙等原因，实测换成 https 的 443 端口会更好。

Host 字段用于区分不同的配置名称，可以设置成任意你觉得便于记忆的样式。

设置完成后，即可进行 Git 仓库的配置：

# 原始
git remote add origin git@github.com:sun2ot/AAA.git
# 修改
git remote add origin git@github-sun2ot:sun2ot/AAA.git

对于默认的 Git SSH 配置，@ 后的域名是 github.com。但这里为了启用我们自定义的 SSH 配置，所以修改为了 ~/.ssh/config 中对应的 Host 字段。

注意事项

请检查你的家目录下是否存在 .gitconfig（好像是叫这个，我记不太清了）文件。该文件会在你执行 git config --global user.name "sun2ot" 等类似的全局操作后产生。

如果存在全局配置文件，则会覆盖你在仓库路径下设置的局部配置。从而产生无论你怎么修改提交的用户，你会发现始终是一个用户（全局用户）提交的。你可以直接删除这个文件，或者从中删除对应的鉴权信息即可。

官网下载 MySQL Community Server

这里的 glibc 版本视情况选择合适的版本。工作站系统更新过，可以直接部署 glibc 2.28 版本。云服务器系统过于老旧，请使用 glibc 2.17 版本。

下载对应的压缩包。如无特殊需求，直接选体积最大的那个拉满即可。

解压

解压压缩包到 /usr/local 下

sudo tar -xJvf mysql-8.4.5-linux-glibc2.28-x86_64.tar.xz -C /usr/local
# 重命名一下文件名，方便后续操作
sudo mv /usr/local/mysql-8.4.5-linux-glibc2.28-x86_64 mysql

为了便于后续操作，先配置环境变量

export "/usr/local/mysql/bin" >> ~/.bashrc
source ~/.bashrc

初始化

创建系统用户和数据目录，为启动 MySQL 做准备

# 新建 mysql 用户（无登录 shell）
sudo useradd -r -s /bin/false mysql

# 建立数据目录并授权
sudo mkdir -p /mnt/mysql/data
sudo mkdir -p /mnt/mysql/log
sudo chown -R mysql:mysql /mnt/mysql

工作站的 MySQL，数据目录是一个 512G 的逻辑卷，挂载在 /mnt/mysql 下。

初始化数据目录（只需要执行一次）。这里只是初始化，还没有启动 MySQL。

sudo /usr/local/mysql/bin/mysqld \
  --initialize-insecure \
  --basedir=/usr/local/mysql \
  --datadir=/mnt/mysql/data \
  --user=mysql

这样 root 初始无密码，后续可用 ALTER USER 'root'@'localhost' IDENTIFIED BY 'YourStrong!Pass'; 设置密码。

编写 MySQL 配置文件：在 /mnt/mysql 下新建一个 my.cnf，插入以下内容并保存。

[client]
port            = 3306

[mysqld]
user            = mysql
port            = 3306
# 开启局域网访问
bind-address    = 0.0.0.0
basedir         = /usr/local/mysql
datadir         = /mnt/mysql/data

# 日志
log-error       = /mnt/mysql/log/mysql.err

# 国际化与插件目录（解决找不到 errmsg.sys、.so 问题）
lc-messages-dir = /usr/local/mysql/share
plugin-dir      = /usr/local/mysql/lib/plugin

# 可根据需要添加优化项，例如：
# max_connections = 200
# innodb_buffer_pool_size = 1G

配置 MySQL 服务

在 /etc/systemd/system 下新建一个 systemd 单元文件 mysqld.service

sudo vim /etc/systemd/system/mysqld.service

插入以下内容：

# /etc/systemd/system/mysqld.service

[Unit]
Description=MySQL Community Server
After=network-online.target
Wants=network-online.target

[Service]
Type=simple
User=mysql
Group=mysql

# 启动命令
ExecStart=/usr/local/mysql-8.4.5-linux-glibc2.28-x86_64/bin/mysqld --defaults-file=/mnt/mysql/my.cnf

# 停止命令
ExecStop=/usr/local/mysql-8.4.5-linux-glibc2.28-x86_64/bin/mysqladmin \
  --defaults-file=/mnt/mysql/my.cnf \
  shutdown

# 异常时自动重启
Restart=on-failure
# 对于“正常退出”（exit code 0）不重启
RestartPreventExitStatus=0

# 打开文件句柄数上限
LimitNOFILE=5000

[Install]
WantedBy=multi-user.target

保存后执行：

sudo systemctl daemon-reload
sudo systemctl enable mysqld

启动 MySQL

# 启动
sudo systemctl start mysqld

# 查看状态
sudo systemctm status mysqld

# 停止
sudo systemctl stop mysqld

# 重启
sudo systemctl restart mysqld

启动 MySQL 后，测试是否能够正常连接

mysql -uroot -p

由于上面通过 --initialize-insecure 参数初始化 MySQL，因此 root 用户默认密码为空，直接回车登录即可。

确认登录成功后，重新设置 root 密码（强密码）：

ALTER USER 'root'@'localhost' IDENTIFIED BY 'YourStrong!Pass';

权限配置

按照上述操作启动 MySQL 后，在终端可以通过 root 进行登录，但是通过远程连接是无法登录的。因为 MySQL 的用户是用户名 + 主机两元组控制的：

如果是自己本机部署 MySQL 开发，root 用户裸奔无所谓。但是服务器部署就需要考虑权限问题，十几个人通过一个 root 账户进行开发是很傻逼的行为。

对于每个用户，按照最小权限原则，只需要授予其需要使用的数据库权限即可。一般一人一个即可，如果有协作开发场景，那就授予多人这个库的权限。

首先，创建数据库。

CREATE DATABASE dev_yzh;

然后，创建需要使用这个库的用户（这个一次就够了，后续都是这几个用户）。

CREATE USER 'yzh'@'172.26.%' IDENTIFIED BY '用户yzh的密码';

这里使用 % 通配符对 IP 进行了限制，即分配 IP 的 172.26 网段。

授予用户 yzh 数据库 dev_yzh 的所有权限。

GRANT ALL PRIVILEGES ON dev_yzh.* TO 'yzh'@'172.26.%';
FLUSH PRIVILEGES;

也可以对权限进行限制，只授予表结构变更和数据操作的权限，保留全局管理操作的权限：

GRANT SELECT, INSERT, UPDATE, DELETE, CREATE, DROP, ALTER
  ON dev_yzh.* TO 'yzh'@'172.26.%';

还可以通过 MySQL 8.0+ 的角色模板进行管理。

Linux 操作系统以其强大的权限管理和开源特性而闻名，相比其他操作系统（如 Windows），它确实更不容易受到病毒和恶意软件的攻击。但某些时刻的确需要一个防病毒软件，可以考虑使用 ClamAV：一款开源的防病毒引擎。

安装

安装 clamav 及其守护进程

sudo apt update
sudo apt install clamav clamav-daemon

执行 clamscan --version，显示版本信息说明安装成功。

官方二进制安装

如果本地的软件源过于老旧，可能导致下载的 clamav 在更新病毒库时被拦截，此时可以直接从官方源安装最新版：

wget https://www.clamav.net/downloads/production/clamav-1.5.1.linux.x86_64.deb
sudo apt install ./clamav-1.5.1.linux.x86_64.deb

使用

配置

[!warning] 当且仅当通过官方二进制安装时，可能需要这一步。否则请直接前往下一步更新病毒库

# 查找配置文件
ls /usr/local/etc | grep clam

会看到

clamd.conf.sample
freshclam.conf.sample

将这两个文件重命名为无 .sample 后缀的形式并编辑，在文件开头找到如下内容：

...
# Comment or remove the line below.
Example
...

注释掉 Example 这一行，即修改为 #Example，然后保存关闭即可。

更新病毒库

第一次安装后，需要手动更新病毒库：

# 先暂停病毒库后台服务，否则无法更新
sudo systemctl stop clamav-freshclam

# 更新病毒库数据
sudo freshclam

# 启动 clamav 服务
sudo systemctl enable clamav-freshclam --now

查看病毒数据库目录及日期

ls -l /var/lib/clamav

扫描文件

默认情况下，clamav 需要手动调用 clamscan 以扫描文件/目录：

# -r 递归扫描
clamscan [-r] /path/to/file_or_path

clamav 会在终端显示扫描过程和结果，如果需要记录到日志，使用 -l 参数：

clamscan /path/to/scan -l /path/to/logfile

其他常用参数：

• -i：inject，仅显示（病毒）感染文件，避免大量刷 Log
• --remove：扫描到感染文件后删除该文件
• --help：帮助信息

脚本示例

以家目录为例，扫描是否存在感染文件。可以添加到 crontab 定时执行。

#!/bin/bash

SCAN_DIR="/home"
EXCLUDE_LIST=(
    "^/home/user1(/.*)?$"
    "^/home/[^/]+/miniforge3(/.*)?$"
    "^/home/[^/]+/\.conda(/.*)?$"
)

EXCLUDE_ARGS=""
for item in "${EXCLUDE_LIST[@]}"; do
    if [[ "$item" =~ \(/.*\)\?$ ]]; then
        EXCLUDE_ARGS+=" --exclude-dir='/$item/' "
    else
        EXCLUDE_ARGS+=" --exclude='/$item/' "
    fi
done

LOG_FILE="/var/log/clamav_home_scan.log"
echo "Scan started at $(date)" >> "$LOG_FILE"
clamscan -r $EXCLUDE_ARGS "$SCAN_DIR" >> "$LOG_FILE" 2>&1
echo "Scan completed at $(date)" >> "$LOG_FILE"

参考文献

• 系统极客：如何安装、配置和使用 ClamAV，守护 Ubuntu 系统安全
• 亚马逊 AWS 官方博客：在 EC2 Linux 操作系统上部署 ClamAV 并开启实时防护、集中日志采集和统一告警

深信服的恶名由来已久，我校不出意外也是使用该公司的 EasyConnect 进行 VPN 连接。由于全局 VPN 走校园网会导致网速缓慢（因为校园网慢啊），且校方当地的网络🚔似乎挺缺业绩的，因此需采取一定的手段封印这个毒瘤软件。

部署 docker-easyconnect

docker-easyconnect: 使深信服（Sangfor）开发的非自由的 VPN 软件 EasyConnect 和 aTrust 运行在 docker 或 podman 中，并作为网关和/或提供 socks5、http 代理服务。

按照官方文档给出的案例启动即可，这里为了方便后期维护，将其改写为 docker-compose.yaml 的形式以便管理：

services:
  easyconnect:
    image: hagb/docker-easyconnect:cli
    container_name: easyconnect
    devices:
      - /dev/net/tun
    cap_add:
      - NET_ADMIN
    volumes:
      - $HOME/.easyconn:/root/.easyconn
    ports:
      - "127.0.0.1:1080:1080"
      - "127.0.0.1:8888:8888"
    environment:
      - EC_VER=7.6.7
      - EXIT=1
      - CLI_OPTS=-d xxx.edu.cn -u xxx -p xxx

关于各参数的作用，参考 doc/usage 即可，这里只对几个关键参数做出说明。

docker-easyconnect 有命令行与图形化界面两种部署形式。由于我校的 VPN 仅需学号 + 密码即可登录，因此只需要命令行部署即可。

在上述的配置文件中：

• ports：端口映射，其中 1080 为 http 端口，8888 为 socks 端口
• EC_VER：easyconnect 的版本，可选 7.6.7/7.6.3，参考 EasyConnect 版本选择
• CLI_OPTS：配置登录信息，其中 -d 指定 VPN 域名，-u 指定用户名，-p 指定密码

使用方式

编辑好镜像文件后，即可启动容器：

docker compose -f xxx.yaml up -d

由于我是在 WSL2 下配置镜像模式使用的，因此容器的网络与宿主机网络完全一致，因此只需要在需要代理的软件中进行配置即可。

关于部署 WSL，可参考 Blog: WSL Docs

例如 ssh 连接内网服务器，只需要设置 proxy （假设使用 socks 代理）为 127.0.0.1:8888 即可登录。

存在的问题

issue 423

暂不清楚什么原因，虽然成功登录，并且可以连接内网服务器，但浏览器设置代理时会访问失败，这导致一些需要校园网络环境的在线服务（如文献）等无法使用容器代理。该问题尚未解决，有待后续补充。

上述问题已解决，原因可参考 issue 154，主要是容器内的 dns 存在问题。按照作者给出的 iptables 方法无法解决，经测试可以通过以下方式解决该问题。

由于 dns 故障，因此对于域名无法解析，此处需分为三种情况：

1. 内网域名可被公开 DNS 解析：此时只需要让代理请求能够在不依赖容器代理的情况下获得该域名的 IP 地址即可，参考下文；
2. 内网域名且只能被私有 DNS 解析：这种情况我暂未遇到，故暂不做考虑。但解决方式可能与情况 1 的一致；
3. 内网页面直接通过 IP 访问，无需域名：这种情况将不会受到 DNS 的干扰，因为无需解析域名获得 IP。

针对情况 1，可以借助 Clash 来完成域名的解析，这里我使用的是 clash-verge-rev，其基于 Meta 内核 构建。主要是需要代理内核支持 hosts 设定即可。

在 Clash 的配置文件中，添加如下内容：

hosts:
  xxx.edu.cn: 1.2.3.4  # 更换为对应的 IP 地址

通过在代理内核中增加 hosts 映射，然后在浏览器中设置代理请求转发到 Clash，即可在容器代理之外获得域名对应的 IP 地址，从而绕过项目原有的 DNS Bug。

nvidia-smi -q -d SUPPORTED_CLOCKS

16 系往后的档位基本都在 15MHz 一档，该命令能够列出当前 GPU 支持的所有档位，便于后续的调整。

设定显卡功耗上限

nvidia-smi -pl [功耗]

单位是瓦特，可以精确到小数点后两位。对笔记本电脑大概率不会生效，需借助 OEM 的控制台实现功耗控制，或者借助下文的频率设定变相实现功耗限制。

锁定核心频率

nvidia-smi -lgc [频率]

固定核心频率。频率需处于显卡支持的档位，并且要能够实现（总不能让你超 10G 吧😅）。

nvidia-smi -lgc a,b

限制核心频率区间（大于 a 小于 b）。打游戏的时候用这个多一点，比较好用。

nvidia-smi -rgc

恢复对频率的任何修改。

重启计算机也是可以的。

锁定显存频率

操作方法与核心频率类似，只不过参数变为 -lmc

# 固定显存频率
nvidia-smi -lmc [频率]

# 固定显存频率区间
nvidia-smi -lmc a,b

# 恢复显存频率
nvidia-smi -rmc

Windows 10 可以通过设置电源模式为节能模式实现关闭睿频，Windows 11 需借助电源计划实现。

打开“控制面板 - 硬件和声音 - 电源选项”，默认的电源计划为 平衡。为使修改的电源计划在重启后仍然生效，需 创建电源计划：

电源计划名字任意，点击 下一页 即可创建完成。

点击创建的电源计划右侧的 更改计划设置，然后 更改高级电源设置:

在弹出的电源选项中，找到 最大处理器状态，将下方的两个值从 100% 修改为 99% 即可关闭 CPU 睿频：

设置处理器频率

默认情况下，电源计划中“处理器电源管理”是没有 处理器最大频率 的设置项的，需要在注册表中手动开启。

找到注册表项：

计算机\HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Power\PowerSettings\54533251-82be-4824-96c1-47b60b740d00\75b0ae3f-bce0-45a7-8c89-c9611c25e100

修改其中的 Attributes 值为 2 即可。

1. 以下期刊排名不分先后，以本文编辑时间当期最新的 Compendex Source List 为准
2. CCF 评级暂只参考计算领域高质量科技期刊分级目录
3. 内容不定时更新

软件学报

自动化学报

电子学报

工程科学与技术

1. 收录计算机科学与技术、人工智能领域的论文，但或许偏应用。请酌情参考。

计算机学报

科学通报（中文）

注：

1. 中文官网极其简陋（各种意义上）
2. 模板需从英文官网下载

计算机集成制造系统

计算机研究与发展

武汉大学学报（信息科学版）

注：

1. 计算机领域跟地理、遥感、图形图像学相关的可投

通信学报

注：

1. 收录范围包括计算机网络、通信等

计算机辅助设计与图形学学报

模式识别与人工智能

注：

1. 虽然这个官网看起来像盗版一样，但就是这么草台班子
2. 以下摘录自期刊模板的原话：

   “因为录用稿件在发表前需要专用软件排版，因此稿件没有明确模板要求。可参阅期刊已发表论文进行排版，包括题目、作者单位、中英文摘要、正文、参考文献和作者信息等。另外，已发表论文正文采用双栏排列，为方便审稿专家审阅，作者可单栏排列。”

计算机工程与应用

注：

1. 截止 2025-01-17，尚未收录到 Elsevier Compendex Source List（文件尚未更新）

机器人

注：

1. 🤖 支持 Overleaf，好文明！

北京航空航天大学学报

注：

1. 自然科学版收录信息与电子技术、计算机科学及应用技术领域文章

北京邮电大学学报

注：

1. 收录的还挺杂，点开热点研究，深度学习、知识图谱、情感分析之类的都有

电子与信息学报

注：

1. 收录范围：图像与智能信息处理、物联网

大学学报汇总

大学弄的学报太多了，就不一一罗列了，反正自己看吧。

• 中南大学学报（自然科学版）
• 中国矿业大学学报
• 中国石油大学学报
• 哈尔滨工程大学学报
• 哈尔滨工业大学学报
• 华中科技大学学报（自然科学版）
• 湖南大学学报
• 吉林大学学报（工学班）
• 国防科技大学学报
• 东北大学学报
• 西北工业大学学报
• 上海交通大学学报
• 华南理工大学学报（自然科学版）
• 东南大学学报（自然科学版）
• 西南交通大学学报
• 电子科技大学学报
• 天津大学学报
• 同济大学学报（自然科学版）
• 清华大学学报
• 西安交通大学学报
• 西安电子科技大学学报
• 浙江大学学报（工学版）
• 北京理工大学学报

存在公网服务器 A 和内网服务器 B。由于不想仅仅为了连接 B 而开启 VPN，因此采用 A 来中转到 B 的 ssh 请求。

操作方式

基础的 ssh 已经足够使用，但如果 A 和 B 的连接不稳定（例如 A 为海外服务器），可能导致 ssh 连接断开。所以这里采用 autossh 来自动维护连接。

sudo apt update
sudo apt install autossh

在内网服务器 B 上执行反向隧道开启命令并使用 autossh 代替 ssh：

autossh -f -M 0 -N -R 4410:localhost:22 -p 2222 sshp@206.237.1.69

参数说明如下：

• -f：后台运行。
• -M 0：禁用 autossh 默认的端口监控功能（推荐使用 ServerAliveInterval）。
• -N：不执行远程命令，仅用于转发。
• -R：定义反向隧道。
• -p 2222：指定公网服务器的 SSH 端口。

上述指令将公网服务器 A 的 4410 端口，映射到内网服务器的 22 端口，该映射关系通过 ssh 连接建立。其中，sshp 是一个公网服务器上已经存在的用户（没有的话需创建）。

因此，对于内网服务器 B，现在可以通过公网服务器 A 来连接：

ssh -p 4410 local_user@A_ip

这里的 local_user 是内网服务器 B 上的用户。至此，通过公网服务器 A 即可连接到内网服务器 B。

sudo apt-get update -qq && sudo apt-get -y install \
  autoconf \
  automake \
  build-essential \
  cmake \
  git-core \
  libass-dev \
  libfreetype6-dev \
  libgnutls28-dev \
  libmp3lame-dev \
  libsdl2-dev \
  libtool \
  libva-dev \
  libvdpau-dev \
  libvorbis-dev \
  libxcb1-dev \
  libxcb-shm0-dev \
  libxcb-xfixes0-dev \
  meson \
  ninja-build \
  pkg-config \
  texinfo \
  wget \
  yasm \
  zlib1g-dev

在 Ubuntu 20.04 上，额外安装：

sudo apt install libunistring-dev libaom-dev libdav1d-dev

部署

首先拉取源码：

git clone https://git.ffmpeg.org/ffmpeg.git ffmpeg_src

配置：

./configure \
--enable-nonfree \
--enable-cuda-nvcc \
--enable-libnpp \
--enable-nvenc \
--bindir="$HOME/app/ffmpeg/bin"

关于 --extra-cflags 和 --extra-ldflags 参数，适用于你的依赖不在默认路径的情况。所以网上很多教程加了这个参数，但通常其实是不需要的。

编译安装：

make -j 32
sudo make install

检查是否部署成功：

记得给生成的 binaries 配置环境变量

ffmpeg -hwaccels
# 输出
Hardware acceleration methods:                                            
vdpau                                                                     
cuda                                                                      
vaapi

ffmpeg -codecs | grep nvenc
# 输出结果中应包含
av1_nvenc, h264_nvenc, hevc_nvenc

排障

编译过程中可能遇到一些缺失依赖问题。可以通过按照 官方文档 的步骤提前安装以规避，也可以在中途按需处理，这里我选择后者。

nasm

报错：nasm not found or too old. Please install/update nasm or use --disable-x86asm for a build without hand-optimized assembly.

参考官方文档 NASM 章节。

nvenc

报错：ERROR: nvenc requested, but not all dependencies are satisfied: ffnvcodec

参考官方文档 Hardware acceleration introduction with FFmpeg 的 NVENC 章节。

这个库本质上只是修改一些文件，速度非常快，无需 make -j

请注意，安装时切记查看 nv-codec-headers 项目主页的 README。不同驱动版本需要切换到不同的 git 分支。

[!tip] 如果你有过 markdown 的写作经历，上手 LaTeX 会特别快

基础说明

LaTeX 的写作本质上是一种非所见即所得的标签化的语言。所有在 Word/WPS 中需要通过鼠标键盘控制样式的部分，只需要通过对应的标签即可控制。

但是，LaTeX 是编辑部用来最终排版的，因此 LaTeX 的 bst 和 cls 文件就控制了整个文档的样式。也就是说，只需要用标签进行样式控制，但不需要对具体的细节进行排版（行高、字体等等）。这些样式也都是编辑部给的模板写死的，严禁修改。部分期刊会对修改了样式的稿件直接退稿，认定为学术不端。

下面会对各种常见的样式进行说明。其实相应的介绍，期刊/会议提供的模板中通常会有一个 PDF 文件，那里面也会详细介绍各种样式的使用说明。不过大体上是类似的，只是不同期刊的部分样式略有不同。

标题

\section{一级标题}
\subsection{二级标题}
\subsubsection{三级标题}

换行

LaTeX 不比 markdown，切记不要随便空行：

1. 文字与公式之间。空行会导致默认创建一个新段落
2. 文字与图片之间，空行不影响段落间距

如果想在编辑器中换行但又不影响渲染效果，有以下几种方式：

1. 借助编辑器插件设置自动换行
2. 在行尾添加 %，这样即使源码中换行也会被忽略

列表

与 markdown 和 Word 类似，LaTeX 的列表也有无序列表和有序列表之分。例如引言中，总结本文的主要贡献时，会使用无序列表：

The main contributions of this work are summarized as follows:
\begin{itemize}
  \item We propose a ...
  \item We design a .
  \item Extensive experiments ...
\end{itemize}

无序列表的样式类似于：

• We propose a ...
• We design a .
• Extensive experiments ...

第二种是有序列表，用的相对较少：

From Tab.1, we can draw some conclusion:
\begin{enumerate}
  \item Text1
  \item Text2
  \item Text3
\end{enumerate}

显示的效果类似于：

1. Text1
2. Text2
3. Text3

不同的期刊对于有序列表的样式控制可能有所不同，主要是前面的序号，可能是 1.，也可能是 1)，或者类似的。因此请参考模板中提供的 PDF 说明文件！

图片

在 LaTeX 中，有几种不同的方式可以插入图像，包括单栏图像、跨两栏图像以及子图等。

单栏图像

单栏图像 figure 是最基本的插入图像的方式：

\begin{figure}[ht]
    \centering  % 控制图片居中
    % []表示参数, width定义了图片的宽度. \textwidth 表示使用单栏的宽度, 0.8 就是这个宽度的 80%
    % {}表示要插入的图像文件
    \includegraphics[width=0.8\textwidth]{image-file.pdf}
    % 图像标题, 注意对于图片来说, 标题在下方, 所以相应的 LaTeX 代码也要写在下面
    \caption{Caption for the figure.} % 根据不同的期刊要求, 决定句末是否要加句点
    \label{fig:label}  % 定义标签, 用于交叉引用. 如果不需要也可以不写
\end{figure}

双栏图像

对于双栏文档，可以使用 figure* 环境来让图像跨越两栏：

\begin{figure*}[ht]
    \centering
    % 对于两栏而言, \textwidth 自动会变成两栏的宽度. 所以与单栏同理，可以通过 0.8\textwidth 来自定义宽度
    \includegraphics[width=\textwidth]{image-file}
    \caption{Caption for the wide figure.}
    \label{fig:wide-label}
\end{figure*}

子图

如果你想在一个图中包含多个子图，可以使用 subfigure 环境（需要 subcaption 包或 subfig 包）。

不同期刊用的包不太一样，注意看一下

使用 subcaption 包的例子如下：

% 所有的 \usepackage 都在 tex 文档的顶部
% 你也可以自行添加其他的包
% 与软件开发的依赖做区分，Latex 的所有包在你安装的时候就部署好了
% 所以基本都是通用的，不用担心你有但编辑部没有
\usepackage{subcaption}
...
\begin{figure}[ht]
    \centering
    \begin{subfigure}[b]{0.45\textwidth}
        \includegraphics[width=\textwidth]{image-file1}
        \caption{Caption of sub-figure 1.}  % 子图标题
        \label{fig:sub1}
    \end{subfigure}
    \hfill % 填充子图之间的空隙, 可以视情况添加
    \begin{subfigure}[b]{0.45\textwidth}
        \includegraphics[width=\textwidth]{image-file2}
        \caption{Caption of sub-figure 2.}  % 子图标题
        \label{fig:sub2}
    \end{subfigure}
    \caption{Overall caption for both sub-figures.}  % 若干个子图的总标题
    \label{fig:both}
\end{figure}

这里演示的是一栏两个子图的情况，所以假设栏宽为 1，就控制每个子图的宽度是 0.45，这样加起来是 0.9 < 1。同理，如果一栏有三个子图，就设置为 0.3。

许注意，不是说加起来小于 1 就一定可以。因为图片本身存在一些不可见的边距，也是要占据宽度的。所以假如一栏三个图，你设置宽度 0.33，那大概率是会被挤下来的。

如果你一栏需要更多的图，就继续添加 \begin{subfigure} ... \end{subfigure} 就好了。

表格

基本表格（三线表）

[!tip] 这里我只对基础表格进行一个比较详细的介绍，后面的都可以参照基础表格进行理解。不然太多了，写的累 😅。

\begin{table}[ht]
    \centering
    % 与图片类似，表格的标题因为在上方，所以\caption要写在上面
    \caption{基本表格示例}
    \label{tab:basic}
    \begin{tabular}{|c|c|c|}
        \toprule
        列1 & 列2 & 列3 \\
        \midrule
        数据1 & 数据2 & 数据3 \\
        数据4 & 数据5 & 数据6 \\
        \bottomrule
    \end{tabular}
\end{table}

这个表格渲染的效果类似于：

首先看到 \begin{tabular} 后面的几个 c：

1. 这里的 c 表示 center，即居中。类似地，左对齐用 l (left)，右对齐用 r (right)
2. 表格一共有 3 列，所以有 3 个 c
3. 每个 c 的左右都有一个 |，这个表示表格竖向的分割线。换言之，如果写成 c c c，就是三线表了

其次，三线表是一个统称。有时并不是真的只有三条线。控制这些横向的线，靠的是三个 *rule：

1. \toprule 表示最上方的横线
2. \midrule 表示表格中间的横线，视情况可以有多条
3. \bottomrule 表示最下方的线
4. 请不要随意使用 \hrule，这玩意生成的线看起来和三线表一样，但是会缺少三线表上下粗、中间细的特点

然后来看分隔符：

1. & 用于区分两个列。如果某一列的值为空，保持空值即可。
2. \\ 表示表格换行

最后，也是最重要的一点。LaTeX 的表格代码编写（阅读）方式是逐行进行的。切记是逐行的，理解这一点，多行/多列表格就很简单了。

浮动表格（跨栏）

与图片类似，单栏的基本表格是 table，跨栏的就是 table*。其余的跟单栏表格一致，不做赘述。

\begin{table*}[ht]
    \centering
    \caption{跨两栏表格示例}
    \label{tab:twocolumn}
    \begin{tabular}{|c|c|c|}
        \hline
        列1 & 列2 & 列3 \\
        \hline
        数据1 & 数据2 & 数据3 \\
        数据4 & 数据5 & 数据6 \\
        \hline
    \end{tabular}
\end{table*}

跨行/跨列表格

跨行/跨列指的是类似于 Excel 中的合并单元格操作。LaTeX 中也有对应的控制方法。这里直接上一个复杂表格，一次性讲清这个问题。

\begin{table}[htb]
\caption{Statistics of benchmark datasets}
\label{tab:dataset}
  \begin{tabular}{cccccccc}
    \toprule
    Dateset & \multicolumn{2}{c}{Yelp} & \multicolumn{2}{c}{Sports} & \multicolumn{3}{c}{Tiktok} \\
    \midrule
    Modality & V & T & V & T & V & T & A \\
    Dim & 512 & 1024 & 4096 & 1024 & 128 & 768 & 128 \\
    \cmidrule(lr){2-3} \cmidrule(lr){4-5} \cmidrule(lr){6-8}
    Users & \multicolumn{2}{c}{37,397} & \multicolumn{2}{c}{35,598} & \multicolumn{3}{c}{9,308} \\
    Items & \multicolumn{2}{c}{32,491} & \multicolumn{2}{c}{18,357} & \multicolumn{3}{c}{6,710} \\
    Interactions & \multicolumn{2}{c}{235,735} & \multicolumn{2}{c}{296,337} & \multicolumn{3}{c}{68,722} \\
    \midrule
    Sparsity & \multicolumn{2}{c}{99.98\%} & \multicolumn{2}{c}{99.95\%} & \multicolumn{3}{c}{99.89\%} \\
    \bottomrule
  \end{tabular}
\end{table}

表格渲染效果如下：

首先注意，表格第一行乍一看只有 4 列，但是每个数据集本质上占据了 2-3 列，所以 \begin{tabular} 后面要列出最多的列数，即 8 个 c。

然后，一个数据集占据了 2-3 列，这个就叫跨列，通过 \multicolumn{列数}{c/l/r => 居中/左/右}{列名}。之前说的逐行阅读就是这个原因，跨列的元素是在一行的编辑中完成的。

类似地，如果是跨行的表格，使用 \multirow{行数}{*}{列名}：

[!warning] 跨行需要添加包 \usepackage{multirow}

\begin{table*}[t]
\centering
\caption{Overall performance comparison}
\label{tab:performance-comparison}
% \resizebox{\textwidth}{!}{
  \begin{tabular}{lcccccccccc}
  \toprule
  \multirow{2}{*}{Method} & \multirow{2}{*}{Venue} & \multicolumn{3}{c}{Yelp} & \multicolumn{3}{c}{Sports} & \multicolumn{3}{c}{Tiktok} \\
  \cmidrule(lr){3-5} \cmidrule(lr){6-8} \cmidrule(lr){9-11}
   & & R@20 & N@20 & P@20 & R@20 & N@20 & P@20 & R@20 & N@20 & P@20 \\
  \midrule
  LightGCN & SIGIR'20 & 0.0599 & 0.0255 & 0.0040
                      & 0.0754 & 0.0335 & 0.0040
                      & 0.0821 & 0.0369 & 0.0041 \\

参考上图，Method 占据了 1-2 行，所以是 \multirow{2}{*}{Method}。需要注意，中间的 * 最好不要改，它可以自动调整。

在编写时可以看到，Method 和 Venue 虽然占据了两行，但是我们在第一行就写了，因此第二行的对应位置需要空出来 空白 & 空白 & R@20 & ...

缩放表格

这是一个很有用的包。有时表格过大会导致即使跨栏分布，表格也摆不下。这个使用可以使用 \resizebox 根据页面大小自动缩放表格。使用方式如下：

[!warning] 使用 \resizebox 需要添加包 \usepackage{graphicx}。

\usepackage{graphicx}

\begin{table}[ht]
    \centering
    \resizebox{\textwidth}{!}{
        % 在原本的 tabular 外面包一层 resizebox 即可
        \begin{tabular}{|c|c|c|c|c|}
            \hline
            列1 & 列2 & 列3 & 列4 & 列5 \\
            \hline
            数据1 & 数据2 & 数据3 & 数据4 & 数据5 \\
            数据6 & 数据7 & 数据8 & 数据9 & 数据10 \\
            % 更多行...
            \hline
        \end{tabular}
    }
    \caption{使用 resizebox 缩小的表格示例}
    \label{tab:resized_table}
\end{table}

resizebox 接受的参数是 \resizebox{宽度}{高度}{内容}，其中内容指的是表格。而宽度和高度的设置通常如上表所示，我们只需要设置宽度为页面宽度 \textwidth，高度设置为 !，LaTeX 就能帮我们自动调整表格大小。

浮动参数

在上文中，可以经常看到在图表后面有 [ht] 这样的标记。这在 LaTeX 中被称为“浮动参数”，它们用于指定浮动体（如图像、表格等）在文档中的理想放置位置。这些参数通常紧跟在浮动环境的开始标签（\begin{figure} 和 \begin{table} 等）之后。

[!warning] 浮动参数只能指定理想位置，这就是本文开头我所说的，LaTeX 是一种非所见即所得的排版方式。也许你想让某个表格在当前页的顶部，但由于位置不够，它就可能会被挤到下一页的顶部。

下面对每一种浮动参数进行解释：

• h：代表 "here"，即尽量将浮动体放置在其出现的文本位置附近。
• t：代表 "top"，表示可以放置在页面的顶部。
• b：代表 "bottom"，意味着可以放在页面的底部。
• p：表示可以单独放在浮动体页上，即该页只包含浮动体。
• !：这个符号意味着 LaTeX 应尽可能地遵循上述位置指示，而不是优先考虑其默认的排版规则。

你可以组合使用这些字母来提供多个位置选项给 LaTeX。例如，[ht] 表示首先尝试在当前位置 (h) 插入浮动体，如果不行，则尝试在页面顶部 (t)。

[!tip] 在 LaTeX 中，图表的位置需要结合浮动参数进行反复尝试、反复调整

交叉引用（非参考文献）

这里的交叉引用指的是图、表、章节标题之类的交叉引用。之所以单独写一节，是因为所有的引用方式都是一样的。

在上面的 图片、表格 章节中，可以看到在 \caption{} 的旁边有一个 \label{}，它能够生成一个标记。

你可以在 tex 文档的任意地方对这个标记进行引用 \ref{}，就可以生成一个可跳转的标记。引用方式如下：

% 假设你插入了一张图
\begin{figure}[ht]
    \centering
    \includegraphics[width=0.8\textwidth]{image-file.pdf}
    \caption{Caption for the figure.}
    \label{fig:framework}
\end{figure}
% 中间可能有一堆内容
Fig.\ref{fig:framework} shows that the modal can effectively learn node features.

LaTeX 会自动对所有的图表编号，所以上面的内容会直接编译为 Fig.1 类似的。

表格的交叉引用和图片是一模一样的。而对于章节，只需要在 \section{} 的旁边也通过 \label{} 创建一个标签即可引用，方法和图表也是完全一样的。

[!tip]

1. label 的名称没有统一格式，你可以任意设置，但最好具有一定的规律。
2. 不要把 label 设置为 fig1, fig2 这种。你能确保 fig1 就永远是第一张图吗？直接以图表的含义作为名称即可。

公式

首先说明，LaTeX 的公式说简单也简单，说复杂也复杂（但其实真的很简单）。这里我只写怎么进行排版，具体的公式应该怎么写，建议自学一下。

关于有一些符号如何输出，给你们提供一个很方便的工具文档 KaTex。基本上所有的符号都可以从上面找到。

此外，如果你此前是用的 mathtype 写的公式，是可以无缝衔接到 LaTeX 的。只需要改一下设置，让 mathtype 复制的内容变为 LaTeX 即可。自行百度一下。

单行公式

先来说单行公式 equation，这个是最简单的：

\begin{equation}
    \mathbf{W}_\text{g} & = \sigma(\mathbf{W}_1\mathbf{P}_m + \mathbf{b}_1)
\end{equation}

$$ \mathbf{W}_\text{g} = \sigma(\mathbf{W}_1\mathbf{P}_m + \mathbf{b}_1) \tag{1}$$

和图表一致，LaTeX 会自动对公式进行编号。

多行公式

如果需要多行公式，通常建议使用 align。使用两个 equation 会让行间距变的很大。

\begin{align}
  \omega_m &= \text{Softmax}(\mathbf{W}_m) \\
  \bar{\mathbf{E}} &= \sum_{m \in \mathcal{M}} \omega_m \cdot \hat{\mathbf{E}}^m
\end{align}

$$ \begin{align} \omega_m &= \text{Softmax}(\mathbf{W}m) \tag{1} \ \bar{\mathbf{E}} &= \sum{m \in \mathcal{M}} \omega_m \cdot \hat{\mathbf{E}}^m \tag{2} \end{align} $$

多行公式也会自动编号。若干个公式之间通过 \\ 进行换行。可以在公式中添加符号 &，这可以指定每一行的公式应该在什么地方对齐。例如上面的例子是在等号 = 处对齐，你也可以放在开头进行左对齐：

\begin{align}
  & \omega_m = \text{Softmax}(\mathbf{W}_m) \\
  & \bar{\mathbf{E}} = \sum_{m \in \mathcal{M}} \omega_m \cdot \hat{\mathbf{E}}^m
\end{align}

$$ \begin{align} &\omega_m = \text{Softmax}(\mathbf{W}m) \tag{1} \ & \bar{\mathbf{E}} = \sum{m \in \mathcal{M}} \omega_m \cdot \hat{\mathbf{E}}^m \tag{2} \end{align} $$

多行公式特例

有时你可能希望多个公式在一起，但是又不要对它们进行多个编号（例如三个公式共用一个编号），那么可以使用 split 环境：

\begin{equation}
  \begin{split}
    \mathbf{H} &= (1+\delta) \cdot (\mathbf{A}_m + \mathbf{I}) \bar{\mathbf{E}} \\
    &= (1+\delta) \cdot \mathbf{G}_m \bar{\mathbf{E}}
  \end{split}
\end{equation}

$$ \begin{equation} \begin{split} \mathbf{H} &= (1+\delta) \cdot (\mathbf{A}_m + \mathbf{I}) \bar{\mathbf{E}} \ &= (1+\delta) \cdot \mathbf{G}_m \bar{\mathbf{E}} \end{split} \tag{1} \end{equation} $$

这种多行公式排版方式和普通的多行公式完全一致，例如 \\ 和 & 的使用，只不过是包裹了一个 split 环境而已。同样支持自动编号

公式引用

公式的引用和上一节的 交叉引用 完全一致。只需要添加一个 \label{} 在 \ref{} 即可：

\begin{equation}
    \label{eq:a_eq}
    \mathbf{W}_\text{g} & = \sigma(\mathbf{W}_1\mathbf{P}_m + \mathbf{b}_1)
\end{equation}
% 正文
Eq.\ref{eq:a_eq} is the formulation that ...

在早期深度学习尚未普及时，Docker 作为一种容器技术是不支持调用宿主机 GPU 的，后面在 Docker 官方以及 NVIDIA 的推动下才得以支持，这其中的关键就在于 NVIDIA Container Toolkit。

通常有两种情况可能会需要 NVIDIA Container Toolkit：

1. 主动：需要 Docker 容器调用 GPU
2. 被动：遇到报错 # docker: Error response from daemon: could not select device driver ““ with capabilities: [[gpu]].

安装

官方文档

首先，需要装好 NVIDIA 显卡驱动。然后配置仓库：

curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg

curl -s -L https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list | sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' | sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list

上述指令切记分两条分别执行，否则会出现看似添加了源但其实没有添加上的尴尬情况。

完成后，更新并安装 NVIDIA Container Toolkit 软件包：

sudo apt update
sudp install -y nvidia-container-toolkit

安装完成后，记得重启 Docker：

sudo systemctl restart docker

Ollama 是一款 开源 框架，专为本地部署和运行大语言模型（LLM）而设计。其特性与功能有很多，这里只列举几个核心点：

1. 简化部署：Ollama 可以让你用 Docker 的方式部署 LLM，这是什么概念不用我多说了吧
2. API 支持：无需额外的 coding 操作，Ollama 本身就支持 API 调用 LLM
3. 跨平台：主要针对 macOS 和 Linux，Windows 目前属于预览性支持
4. Python SDK 支持

Ollama 支持的模型可以在 Ollama Library 中检索。

GPU 支持

我没玩过 A 卡，所以这里只记录 N 卡的情况。更多内容可参考 Ollama GPU。

大模型不坑穷人，所以请注意：运行 7B 模型需要至少 8GB 的显存，13B 模型需要至少 16GB，33B 模型需要至少 32GB。

Ollama 支持 compute capability (计算能力) 5.0+ 的 Nvidia GPU，如下表所示。如果不清楚你的 GPU 计算能力是多少，可在 cuda-gpus 查询。

部署方式

下文以 Linux 为例

推荐使用脚本部署：

curl -fsSL https://ollama.com/install.sh | sh

手动部署 也不麻烦，如果有需要参考官方文档即可。

最佳实践

以最新的 Llama3.1 模型为例，部署该模型只需要：

ollama run llama3.1

搞定。

关于 API 的使用

这里纠正一个误区：执行 ollama run model 命令会进入 CLI 交互模式，此时可以与大模型进行对话。

但如果只是需要调用模型 API，执行 ollama serve 即可。此时 ollama 会监听本地的 11434 端口，并提供 RESTful API，此时 ollama 对系统占用可忽略不计。

可参考 API 文档 直接发起请求，ollama 会自动加载模型到 GPU 进行计算。如果一段时间内没有继续请求，模型会自动卸载。

环境变量

这里主要说明两个，一个是多 GPU 环境，另一个是局域网访问，这应该也是最常见的问题。

如果具有多 GPU 环境，ollama 会自动调用多 GPU 加速计算（前提是模型足够大）。但我相信富哥还是少数😭，更多的需求是指定 ollama 使用一个或几个特定的 GPU。

此外，ollama 默认工作在 127.0.0.1 上，可以通过 nginx 做反代访问，也可以通过环境变量 OLLAMA_HOST 设置。

常规情况下，安装 Ollama 后，可通过 systemd 管理其服务。因此可在 /etc/systemd/system/ollama.service 中添加上述环境变量，如下：

[Unit]
Description=Ollama Service
After=network-online.target

[Service]
ExecStart=/usr/local/bin/ollama serve
User=ollama
Group=ollama
Restart=always
RestartSec=3
Environment="CUDA_VISIBLE_DEVICES=1"
Environment="OLLAMA_HOST=0.0.0.0"

[Install]
WantedBy=default.target

但如果处于容器环境，尤其是没有使用 systemd 的容器环境，默认情况下，ollama 完成后是不会自动启动的，如：

ollama list

Error: could not connect to ollama app, is it running?

此时可以在 shell 配置文件中添加环境变量，实现上述效果：

vim ~/.bashrc # ~/.zshrc

# 添加如下内容
export OLLAMA_HOST=0.0.0.0:11434
export OLLAMA_MODELS=/home/user/ollama

然后手动启动 ollama：

nohup ollama serve > ollama.log 2>&1 &
# 如有需要，可执行
disown

Open WebUI

如果只使用 Ollama，那么跟模型的交互仅限于 CLI 和 API 两种方式。如果想实现 chatgpt 类型的页面交互模式，需要借助额外的前端框架，可参考官方提供的 Web&Desktop 目录。

下面以 Open WebUI 为例，推荐使用 Docker 进行部署：

docker run -d -p 3000:8080 --gpus all --add-host=host.docker.internal:host-gateway -v open-webui:/app/backend/data --name open-webui --restart always ghcr.io/open-webui/open-webui:cuda

注意：启动容器之前，需要先部署 NVIDIA Container Toolkit

这里不推荐本地的映射卷路径，实测会出现一些问题，例如：

huggingface_hub.utils._errors.LocalEntryNotFoundError: Cannot find an appropriate cached snapshot folder for the specified revision on the local disk and outgoing traffic has been disabled. To enable repo look-ups and downloads online, pass 'local_files_only=False' as input.

大概率是因为修改了映射卷位置所导致的，见 open-webui issue: 2758

Ollama + LangChain

先画个饼，后面再写。

"Generate_204" 是一种网络连通性测试服务，广泛应用于检查网络连接状态。它通过访问一个返回 HTTP 204 状态码的 URL 来判断当前网络是否畅通，所以叫做 generage_204。

由于 HTTP 204 表示请求已成功处理且没有返回内容，访问这些 URL 可以有效减少网络开销，并且迅速判断网络连接情况。

许多知名的互联网公司提供这些服务，包括 Google、Apple、Cloudflare 等。根据互联网的检索信息，国内的 华米OV 中前三家似乎也提供了这种服务。这里统计一下常见的 generate_204 URL：

一般情况下，使用微软的就不错，因为 Windows 的联网判断方法用的就是这个。

提示词反推

文生图的流程是给提示词然后生成对应图片，而如果要将一个人像转为二次元，一个靠谱的方案是先获得这个人像对应的提示词，这能帮助 sd 模型生成的图像尽可能贴近原图像。

对于 sd webui，这需要提示词反推插件来实现：

https://github.com/67372a/stable-diffusion-webui-wd14-tagger.git

原本的 wd14 tagger（也就是你在网上各种教程、视频里看到的那个插件）已经 public archive 了，所以上面提供的是一个近期更新过的可用版本。

安装完成后进入 Tagger 选项卡，按照上图所示操作，会自动下载反推所需模型。

自动从 hugging face 下载，需要代理环境。

将生成的正向提示词 Send to txt2img 后，点击 Unload all interrogate models 卸载反推模型以节省显存占用。

controlnet 模型

具体的操作流程参考教程： https://www.uisdc.com/stable-diffusion-27

下面主要给出这个教程涉及到的模型资源（涉及下载部分需代理环境）：

1. Preprocessor 1：
   • openpose_full：下拉菜单选中预处理器后，点击右侧按钮自动下载
   • 对应的 Model：control_sd15_openpose.pth
2. Preprocessor 2：
   • softedge_pidinet：与 openpose_full 相同，选中后点击自动下载
   • 对应的 Model：control_v11p_sd15_softedge.pth 和 control_v11p_sd15_softedge.yaml

基底大模型用的是ReV Animated

最终效果

Windows 的就不介绍了，一是因为使用 Windows 大部分是个人机，具有完全操作权限，因此没什么操作难度；二是相关的资料实在太多。

准备工作

1. 代理环境（没有也不是不行，不过稍微麻烦点，下文会给出解决方案）
2. git
3. 具有较新版本驱动的 NVIDIA GPU（我的服务器使用的 Driver Version: 535.183.01 CUDA Version: 12.2）
   • 不要用最新的，因为大概率不兼容
4. conda/mamba 环境

部署过程

首先创建一个 Python 3.10.6 版本的虚拟环境：

必须是这个版本

conda create -n sdw python=3.10.6
conda activate sdw

然后克隆仓库（这是原版的 sdw，不是第三方的）：

git clone https://github.com/AUTOMATIC1111/stable-diffusion-webui.git

下载依赖和模型：

cd stable-diffusion-webui
./webui.sh

问题说明

理论上说，在网络和驱动没有问题的情况下，按照上述部署过程，等一段时间后就可以正常启动 sd webui。但多数情况下不会如此顺利，所以这里对几个常见的问题做出说明。

关于代理

如果你知道如何在 Linux 部署 clash 等代理客户端，那么只需要在执行依赖安装前，执行

export https_proxy=http://127.0.0.1:7890 http_proxy=http://127.0.0.1:7890;

此后无论是从 GitHub 还是 hugging face 下载，都会走代理环境。

如果你不清楚这是什么，那就按照“依赖安装”一节中的内容逐步操作。

依赖安装

从事深度学习的可能会发现一个问题，sd webui 使用的是 Python 自带的 venv 虚拟环境，这玩意显然是没有 conda/mamba 好用的，那可不可以将依赖安装在后者然后启动呢？

经过实测以及检索各方信息，我的建议是别这么干，原因如下：

1. 代码能跑时，就不要去改它，这个道理 coder 应该都懂
2. 我试图通过 pip install -r requirements.txt 在 conda 环境中预先下载环境，也确实能跑起来，但就本质来说，隔离环境这一点跟 venv 没有区别啊
3. 此外，许多功能官方都封装在了 webui-user.sh/bat 的参数中。如果选择 conda 环境，将舍弃这一便利性，需要自行修改代码中相关参数。

综上，与其不断试错，不如配置好镜像和代理，使用 ./webui.sh 安装。

# pip 镜像
pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple

由于该模型需要从 hugging face 下载，所以这里建议手动从 镜像站 下载，然后移动到项目路径下的 models/Stable-diffusion。

由于模型文件较大，下载完成后记得校验 sha256 以确保文件未损坏。

上述工作完成后，执行 ./webui.sh 等待即可。

如果依赖安装完成后，启动时报错 torch 相关错误，请检查以下两点：

1. 驱动版本是否合适（驱动版本太老，你又不是管理员，那还是歇了吧）
2. 参考下文“torch 版本”一节

局域网访问

默认情况下，sd webui 运行在 127.0.0.1:7860，不支持本机以外设备访问。可以修改 webui-user.sh 中的 COMMANDLINE_ARGS 解决：

export COMMANDLINE_ARGS="--listen"

修改后重启 sd webui，将会在 0.0.0.0:7860 上启动。

关于 GPUs

稳定扩散模型 stable diffusion 本质上不支持跨多个 GPU 的并行工作，见 issue 11646。但如果你有多个 GPU，想运行多个 sd webui 实例，或者想让 sd webui 运行在某个指定的 GPU 上，可以通过 --device-id 参数实现：

export COMMANDLINE_ARGS="--device-id 1"

注意，export COMMANDLINE_ARGS="--device-id 0,1" 是错误的，不可识别。

torch 版本

sd webui 所需要的 pytorch 版本，按照 nvidia-smi 显示的 cuda 版本去下载，而不是 nvcc -V 所显示的 Runtime API 版本。

至于哪个版本可用，这是一个经验论问题，反复试错即可。

所有参数

https://github.com/AUTOMATIC1111/stable-diffusion-webui/wiki/Command-Line-Arguments-and-Settings

二维码生成

这一步借助 webui 的插件 qrcode-toolkit 实现。

controlnet 模型

先下载 webui controlnet 插件，然后下载两个控制模型：

1. qrcode moster：
   • control_v1p_sd15_qrcode_monster.yaml
   • control_v1p_sd15_qrcode_monster.safetensors
2. latentcat/latentcat-controlnet：
   • control_v1p_sd15_brightness.safetensors

这三个文件都放在 extensions/sd-webui-controlnet/models 下。

给出的链接都是 hugging face 的镜像站，直接下载即可。

然后按照下文使用 API Key 下载基底大模型 ReV Animated。注意，Overview 中推荐搭配 VAE 和 Negative Prompt Embeddings 使用，我这里仅加载了一个 orangemix.vae.pt。

关于 controlnet 的参数说明，可以参考如下视频，这里不过多赘述：

<iframe width="560" height="315" src="https://www.youtube.com/embed/HyQxGnQNAHI?si=gQq49tUCN4iX-l7K" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>

如果只是想关注如何用 stable diffusion webui 实现二维码生成，那建议直接看这个视频：

<iframe width="560" height="315" src="https://www.youtube.com/embed/4CCZlwF4mro?si=plUcnKaspeHFUAfJ" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>

使用 civitai API

有的模型 C 站要求登录后才能下载，因此直接 download 直链是不 work 的，需要使用 API Key。

按照路径：右上角头像 ➡️ Account settings ➡️ API Keys，新增一个 API Key。

[!caution] 警告 虽然约定俗成但还是说一句：注意页面上的提示，弹出的 API Key 只会出现一次，记得保存下来。

按照如下格式在下载链接中添加 token 参数即可下载：

wget "https://civitai.com/api/download/models/425083?type=Model&format=SafeTensor&size=full&fp=fp32&token=xxx" --content-disposition

主要是 &token=xxx

FAQ

报错 Expecting value: line 1 column 1 (char 0)

该问题与代理有关，关闭代理后重启即可。如果不想关闭代理，可修改 webui-user.bat，添加参数 --no-gradio-queue

set COMMANDLINE_ARGS=--no-gradio-queue

Linux 类似地修改 webui-user.sh 即可。

下载安装

进入 neo4j deployment center，页面往下拉，找到 Graph Database Self-Managed，选择对应配置下载压缩包。

[!tip] 注意，选择社区版(community)，企业版是收费的。

然后解压出来：

tar -zxvf neo4j-community-4.4.35-unix.tar.gz

进入解压出的路径 neo4j-community-4.4.35 后，主要关注两个地方：

1. bin：neo4j 的二进制执行文件
2. conf：neo4j 的配置文件

通常情况下，需要使用 bin/neo4j 来管理 Neo4j 服务，所以还需要配置一个环境变量方便使用：

vim ~/.bashrc # 或者 ~/.zshrc

# 在最下方插入如下内容(注意替换)
export PATH="path/to/your/neo4j-community-4.4.35/bin:$PATH"

# 保存退出文件

# 生效环境变量
source ~/.bashrc

然后执行 neo4j status，查看是否正常执行，输出 Neo4j is not running. 表示配置成功。

配置 jdk11 环境

Neo4j 4.X 依赖于 jdk11，所以还需要配置一个 Java 环境。

服务器已经在 /opt 下部署了常用环境的二进制包，因此直接配置环境变量即可。

vim ~/.bashrc # 或者 ~/.zshrc

# 在最下方插入如下内容(注意替换)
export JAVA_HOME=/opt/jdk-11.0.22
export PATH=$JAVA_HOME/bin:$PATH
export JRE_HOME=$JAVA_HOME/jre
export CLASSPATH=.:$JAVA_HOME/lib

# 保存退出文件

# 生效环境变量
source ~/.bashrc

完成后输入 java --version，返回如下信息表示配置成功：

java 11.0.22 2024-01-16 LTS
Java(TM) SE Runtime Environment 18.9 (build 11.0.22+9-LTS-219)
Java HotSpot(TM) 64-Bit Server VM 18.9 (build 11.0.22+9-LTS-219, mixed mode)

[!tip] 注意是 java，不是 openjdk 😅

配置 Neo4j

由于 Neo4j 社区版只支持单实例，无法做集群，所以多用户使用时，要修改默认端口防止冲突。

[!tip] 可以简单理解为部署一个 neo4j 只能给一个人用，不像数据库，部署一次可以服务多个用户。

Neo4j 的配置通过编辑文件 conf/neo4j.conf 进行。

首先修改 http 端口。在配置文件中找到如下内容，删除前面的井号 # 取消注释，并修改对应的端口：

# 修改前
#dbms.connector.http.listen_address=:7474
#dbms.connector.http.advertised_address=:7474

# 修改后
dbms.connector.http.listen_address=:7475
dbms.connector.http.advertised_address=:7475

然后修改 bolt 协议的端口。

# 修改前
#dbms.connector.bolt.listen_address=:7687
#dbms.connector.bolt.advertised_address=:7687

# 修改后
dbms.connector.bolt.listen_address=:7688
dbms.connector.bolt.advertised_address=:7688

最后修改数据库默认的监听地址。如果你只需要在本机使用 Neo4j，没有局域网访问的需求，可以不做这一步。

dbms.default_listen_address=0.0.0.0

使用 Neo4j

# 启动
neo4j start

# 停止
neo4j stop

# 重启
neo4j restart

# 检查状态
neo4j status

基本原理

粒子群算法（Particle Swarm Optimization, PSO）是一种基于群体智能的优化算法。它通过模拟鸟群或鱼群等社会动物的群体行为来寻找最优解。可以假设这样一个场景：在一个区域里只有一个食物源，有一群鸟在觅食。所有鸟都不知道食物在哪里，但是它们知道当前的位置离食物还有多远。那么找到食物的最佳策略是什么呢？最简单有效的方法是搜索目前离食物最近的鸟的周围区域并根据自身经验判断食物的位置。

鸟群在寻找食物的过程中，个体之间存在信息交流和共享，每个成员可以从其他成员的搜索经验中获益，并调整自身的搜索行为。当食物源不可预测其分布状态时，这种个体之间的协作所产生的优势是巨大的。

• 在 PSO 中，把一个优化问题看作是在空中觅食的鸟群，那么“食物”就是优化问题的最优解，而在空中飞行的每一只觅食的“鸟”就是 PSO 算法中在解空间中进行搜索的一个“粒子”(Particle)。
• 粒子在搜索空间中以一定的速度飞行，这个速度根据它本身的飞行经验和同伴的飞行经验来动态调整。所有的粒子都有一个被目标函数决定的适应值（fitness value），这个适应值用于评价粒子的“好坏”程度。
• 每个粒子知道自己到目前为止发现的最好位置（particle best，记为 pbest）和当前的位置，pbest 就是粒子本身找到的最优解，这个可以看作是粒子自己的飞行经验。
• 除此之外，每个粒子还知道到目前为止整个群体中所有粒子发现的最好位置 (global best，记为 gbest)，gbest 是在 pbest 中的最好值，即是全局最优解，这个可以看作是整个群体的经验。

数学模型

粒子群算法（Particle Swarm Optimization, PSO）是通过模拟群体行为来解决优化问题的算法。它的核心在于每个粒子在搜索空间中不断调整其位置和速度，以接近全局最优解。下面介绍粒子群算法的数学模型，包括位置和速度的更新公式及其相关参数。

初始化

首先，初始化粒子群，包括每个粒子的初始位置和速度。假设粒子群由 $N$ 个粒子组成，每个粒子在 $D$ 维空间中。

• 粒子 $i$ 的位置： $\mathbf{x}i = (x{i1}, x_{i2}, \ldots, x_{iD})$
• 粒子 $i$ 的速度： $\mathbf{v}i = (v{i1}, v_{i2}, \ldots, v_{iD})$
• 粒子 $i$ 的个体最优位置（个体最优解）：$\mathbf{pbest}i = (p{i1}, p_{i2}, \ldots, p_{iD})$
• 全局最优位置（全局最优解）：$\mathbf{gbest} = (g_1, g_2, \ldots, g_D)$

速度更新公式

粒子 $i$ 在第 $t+1$ 代的速度由以下公式更新：

$$ \mathbf{v}_i(t+1) = w \cdot \mathbf{v}_i(t) + c_1 \cdot r_1 \cdot (\mathbf{p}_i(t) - \mathbf{x}_i(t)) + c_2 \cdot r_2 \cdot (\mathbf{g}(t) - \mathbf{x}_i(t)) $$

其中：

• $w$ 是惯性权重，控制粒子的惯性对速度的影响。
• $c_1$ 是个体学习因子，衡量粒子自身经验的重要性。
• $c_2$ 是社会学习因子，衡量粒子借鉴群体经验的重要性。
• $r_1$ 和 $r_2$ 是两个独立的均匀分布的随机数，范围在 [0, 1] 之间，增加搜索的随机性。

式子的三个部分也可以看作：粒子先前的速度 + 自身认知项（认知组件） + 群体认知项（社交组件）

位置更新公式

粒子 $i$ 在第 $t+1$ 代的位置由以下公式更新：

$$ \mathbf{x}_i(t+1) = \mathbf{x}_i(t) + \mathbf{v}_i(t+1) $$

位置是一个空间坐标，所以位置更新要加上整个空间内的位移

适应度评估

每个粒子的适应度值 $f(\mathbf{x}_i)$ 是其位置 $\mathbf{x}_i$ 对应的目标函数值。适应度评估用于更新个体最优位置和全局最优位置：

• 如果 $f(\mathbf{x}_i(t+1))$ 优于 $f(\mathbf{pbest}_i(t))$，则更新个体最优位置：$\mathbf{pbest}_i(t+1) = \mathbf{x}_i(t+1)$
• 如果 $f(\mathbf{pbest}_i(t+1))$ 优于 $f(\mathbf{gbest}(t))$，则更新全局最优位置： $\mathbf{gbest}(t+1) = \mathbf{pbest}_i(t+1)$

终止条件

算法反复进行速度和位置的更新，直到满足以下停止条件之一：

• 达到预设的最大迭代次数。
• 全局最优位置的适应度值在若干次迭代中没有显著改善。
• 全局最优位置的适应度值达到了预设的阈值。

参数设置

粒子群算法的性能在很大程度上依赖于参数的设置：

• 惯性权重 ( w )：一般在 [0.4, 0.9] 范围内选择，通常随时间递减。
• 个体学习因子 ( c_1 ) 和社会学习因子 ( c_2 )：通常都设置为 2。
• 速度限制 $v_{\text{max}}$：限制粒子的速度以防止其移动过快，一般取值为位置范围的 10% 到 20%。

粒子群算法解决函数优化问题

Rosenbrock 函数是一个经典的测试函数，用于验证优化算法的性能，其定义如下：

$$ f(x,y)=(a-x)^2+b \cdot (y-x^2)^2 $$

该函数有一个全局最小值点，当 $a=1, b=100$ 时，全局最小值点位于 $(x,y)=(1,1)$，此时函数值为 0。函数在该点附近呈现一个狭长的谷底，这使得优化问题具有挑战性。

代码实现

基本原理

模拟退火算法（Simulated Annealing，SA）的基本思想来源于固体退火过程。在退火过程中，固体被加热到高温，使得原子可以自由移动，然后逐渐降低温度，系统逐渐冷却并达到稳定状态，最终原子排列在能量最低的基态。

具体来说，模拟退火算法通过在解空间中随机采样，并允许一定的“退步”来避免陷入局部最优解，从而接近全局最优解。算法的关键在于“接受概率”，即是否接受一个较差解的概率随着温度的降低而降低。

把问题看作固体内部粒子，把最优解看作平衡态，用程序模拟退火的过程，就是模拟退火算法。

数学模型

热力学定义与 Boltzmann 分布

在统计物理学中，Boltzmann 分布描述了一个系统在温度 T 下，系统在不同能量状态 $E_i$ ​ 的概率分布。具体形式为：

$$ P_i(T)=\frac{exp(\frac{-E_i}{k_B T})}{Z} $$

• $P_i(T)$ 是系统在温度 T 下处于状态 i 的概率
• $k_B$ 是 Boltzmann 常数
• $Z$ 是配分函数，表示系统所有可能状态（共 n 个）的概率之和，确保概率总和为 1，即 $$ Z=\sum_j exp(\frac{-E_j}{k_B T}) $$

模拟退火算法中的应用

假设热力学系统 S 有 n 个离散的状态，其中状态 i 的能量表示为 $E_i$。设在温度 $T_k$ 下系统达到热平衡，此时处于状态 i 的概率为：

$$ P_i(T_k)=C_k exp(\frac{-E_i}{T_k}) $$

上式可以被理解为对 Boltzmann 分布的简化形式，其中 $C_k$ 是一个归一化常数（类似于配分函数的倒数），确保所有状态概率之和为 1，即

$$ C_k=\frac{1}{\sum_{i=1}^n exp(\frac{-E_i}{T_k})} $$

在模拟退火算法中，该方程用于计算接受一个较差解的概率，这个概率决定了算法是否接受一个能量较高的新解，以便跳出局部最优解并朝向全局最优解。

也就是智能优化算法中的从当前状态转移到新状态的转移（接受）概率。

温度对概率的影响

假设在同一温度 T 下，有两个不同的能量状态 $E_1 < E_2$，那么

$$ \frac{P_1(T)}{P_2(T)}=exp(-\frac{E_2-E_1}{T}) $$

因为 $E_1 < E_2$，所以 $exp(-\frac{E_2-E_1}{T})<1$，即 $P_1(T)<P_2(T)$。这说明在相同温度下，系统处于能量小状态的概率比处于能量大状态的概率要大。此时，模拟退火算法可以在部分高质量解区域进行重点搜索，提高搜索效率。

当 $T_k$ 很大，即温度高时，$\frac{E_i}{T_k} \rightarrow 0$，因此

$$ P_i(T_k)=C_k exp(\frac{-E_i}{T_k}) \rightarrow C_k = \frac{1}{\sum_{i=1}^n exp(\frac{-E_i}{T_k})} = \frac {1} n $$

这表示在温度高时，系统处于任意能量状态的概率基本相同，接近 1/n。此时，模拟退火算法可以在解空间任何区域进行搜索（广域搜索），避免早熟收敛。

当 $T_k \rightarrow 0$ 时，$\frac{E_i}{T_k} \rightarrow \infty$，此时系统将无限接近能量最低状态，且低温下对能量差异非常敏感，即 $E_i$ 和 $E_j$ 的小差别会带来 $P_i(T_k)$ 和 $P_j(T_k)$ 的巨大差异。此时，模拟退火算法无限接近全局最优解（能量最低状态）。

算法模拟

模拟退火算法（SA）的模拟有三个要求：

1. 初始温度足够高
2. 降温过程足够慢
3. 终止温度足够低

SA 通过接受较差解的策略来避免陷入局部最优解，最终收敛到全局最优解。这种接受较差解的概率由 Boltzmann 分布控制，其公式为：

$$ P(E,E',T)=exp(\frac{-\Delta E}{T}) $$

其中：

• $E$ 是当前解的目标函数值
• $E'$ 是新解的目标函数值
• $\Delta E = E'-E$ 是目标函数值的变化
• $T$ 是当前温度

模拟退火算法的构造

算法主要分为以下三个部分：

1. 初始解和初始温度：
   • 选择一个初始解 $S_0$。
   • 设定一个初始温度 $T_0$（足够高）
2. 退火调度：
   • 设定温度下降的策略（退火调度），如线性降温、指数降温等。
3. 终止条件：
   • 设定算法的终止条件，如温度降到一定阈值或者经过一定次数的迭代后停止。

具体的算法步骤如下：

1. 初始化：
   • 选择初始解 $S$
   • 设定初始温度 $T$
   • 设定温度下降的策略，例如 $T=rate*T$
   • 设定初始迭代次数 $k=0$
2. 迭代过程：
   • 生成新解：从当前解 $S$ 的邻域中随机选择一个新解 $S'$
   • 计算能量差：计算新解与当前解的能量差 $\Delta E = E(S')-E(S)$
   • 接受概率：根据 Boltzmann 分布计算接受新解的概率 $P(E,E',T)=exp(\frac{-\Delta E}{T})$
     • 如果 $\Delta E < 0$（温度降低），接受新解（即 $S \leftarrow S'$）
     • 如果 $\Delta E \ge 0$，以概率 $P$ 接受新解
   • 更新温度：根据退火调度函数更新温度 $T$
   • 更新迭代次数：$k \leftarrow k+1$
3. 终止条件：
   • 如果达到终止条件，输出当前解 $S$ 作为最终结果
   • 否则，返回步骤 2 继续迭代

SA 算法解决调度问题

问题定义

调度问题（Scheduling Problem）通常涉及将一组任务（作业）分配给有限的资源（例如机器、工人或时间段），以优化某个目标。常见的目标包括最小化总完成时间、最小化延迟或最大化资源利用率。

• 有 n 个作业，每个作业需要一定的处理时间。
• 有 m 台机器，每台机器可以并行处理一个作业。

目标：将这些作业分配到机器上，使得所有机器的总完成时间（Makespan）最小化。

Makespan：所有机器的最大完成时间，即最后一个完成作业的时间。

• 假设有两个机器和 4 个作业，执行时间分别为 [2, 4, 6, 8]。一种可能的分配是：
  • 机器 1：作业 1 (2), 作业 3 (6)
  • 机器 2：作业 2 (4), 作业 4 (8)
• 机器 1 的总完成时间是 2 + 6 = 8
• 机器 2 的总完成时间是 4 + 8 = 12
• Makespan 是两者中的最大值，即 12

调度问题的目标就是找到一种分配，使得这个最大值最小。

算法实现

完整代码

基本原理

蚁群优化（ant colony optimization, ACO）算法是一种源自大自然生物世界的仿生类算法，其思想充分吸收了蚁群在觅食过程中的行为特性。

蚁群觅食，每只蚂蚁在经过的路上会留下一种化学物质，称为信息素，信息素会随着时间逐渐挥发，也就是说找到食物越慢，这条路上的信息素残留越少。其他蚂蚁可以感受到信息素的存在，并且能测量信息素的浓度。

通常蚂蚁会沿着信息素最浓的方向行走，毕竟是前人经验嘛，这样这条路上的信息素越来越浓；但偶尔也会突发奇想，试着走走信息素没那么浓，甚至没有信息素的路径，可能更快找到了食物。那么新路径信息素浓度很大，但也可能找不到食物，直到信息素挥发完毕。

如此反复，经过大量蚂蚁重复多次的探索，最终摸索出一条最短的路径；当然 不一定是全局最短，这点就不解释了。

数学模型

蚁群算法的基本迭代过程如下：

1. 初始化信息素：在所有路径上初始化一个较小的初始信息素值。
2. 每只蚂蚁构建路径：
   • 每只蚂蚁根据当前的信息素和启发式信息（如路径距离、时间等）选择路径，从起点到达终点。
   • 在路径选择过程中，蚂蚁会逐步走完整个路径，但此时并不会更新信息素。
3. 路径评估与信息素更新：
   • 在所有蚂蚁都走完路径后，收集每只蚂蚁的路径信息。
   • 计算每只蚂蚁在其路径上留下的信息素量​。
   • 叠加所有蚂蚁在每条路径上留下的信息素，更新全局信息素矩阵。
4. 挥发信息素：应用信息素挥发公式，使信息素浓度逐步减小，保持探索能力。

状态转移概率

这玩意决定了蚂蚁选择走哪条路。

• $P^k_{i,j}(t)$ 是状态转移概率，代表 t 时刻，第 k 只蚂蚁在 i 点选择往 j 点走的概率；
• allowed 表示蚂蚁 k 下一步允许选择的城市；
• $\tau_{ij}$ 表示 i，j 两点之间的信息素浓度
• $\alpha$ 是信息素启发因子，控制着 $\tau_{i,j}$ 对路径选择的影响程度：
  • 值越大，越依赖信息素，探索性降低；
  • 值越小，蚁群搜索的范围减少；
• $\eta_{ij}$ 表示 i，j 之间的能见度，反映了由 i 到 j 的启发程度，因此也叫启发函数
  • 通常取 i，j 距离 $d_{ij}$ 的倒数
  • 距离越短，启发函数值越大，因此表示蚂蚁在两点间转移的期望程度
• $\beta$ 是期望值启发因子，表示能见度的相对重要性，反映蚂蚁在运动过程中启发信息在蚂蚁选择路径中的受重视程度：
  • 值越大，则状态转移概率越接近于贪心规则（距离越短我越走嘛）；

注意这里的 t 虽然译为“时刻”，但其实是迭代的次数，即 m 只蚂蚁全部走完一次后，才会加一。

信息素更新公式

初始化信息素浓度

$$ \tau_{ij} = O $$

如果 O 太大，算法容易早熟，蚂蚁会很快的全部集中到一条局部最优的路径上。反之，如果 O 太小，信息素对搜索方向的指导作用太低，也会影响算法性能。

信息素更新规则

$$\tau_{ij}(t + 1) = (1 - \rho) \tau_{ij}(t) + \sum_{k=1}^{m} \Delta \tau_{ij}^k(t)$$

其中：

• $\tau_{ij}(t)$ 表示在时刻 t 路径 (i, j) 上的信息素浓度。
• $\rho$ 是信息素挥发系数，$0 < \rho < 1$。
  • 信息素随时间的衰减，能避免信息素无限累积，使得算法能不断探索新的路径，防止陷入局部最优。
• $\Delta \tau_{ij}^k(t)$ 是第 k 只蚂蚁在时刻 t 经过路径 (i, j) 时留下的信息素量，因此信息素增量是整个蚁群产生的增量。
  • 信息素的增量通常与路径的质量相关，路径越短（即质量越好），新增的信息素越多。

始终记得，在蚁群算法中，信息素更新是基于一次完整迭代中的所有蚂蚁行动结果进行的，而不是在每只蚂蚁行动之后立即更新。具体地说，公式中的 m 指的是当前迭代中参与路径构建的所有蚂蚁，即蚁群数量。

三种基本蚁群算法模型

$\Delta \tau_{ij}$ 的计算方法取决于具体的蚁群算法实现，常见的方法包括以下 3 种。这些模型的区别在于蚂蚁在路径上留下信息素的方式。

蚂蚁圈模型（Ant Cycle Model）

在蚂蚁圈模型中，信息素的更新发生在所有蚂蚁完成路径之后，综合每只蚂蚁的路径质量进行更新（全局更新）。这是最常用的蚂蚁算法模型。

其中 $\Delta \tau_{ij}^k$ 的一个常见的选择是：

$$\Delta \tau_{ij}^k = \begin{cases} \frac{Q}{L_k} & \text{如果蚂蚁 } k \text{ 经过了路径 } (i, j) \ 0 & \text{否则} \end{cases}$$

其中 Q 是一个常数， $L_k$ 是第 k 只蚂蚁在本次迭代所走路径的总长度。

蚂蚁数量模型（Ant Quantity Model）

在蚂蚁数量模型中，蚂蚁在经过路径时留下的信息素为变量。属于局部更新，即信息素的更新是沿路径在每个节点处逐步进行的，而不是等所有蚂蚁完成路径后再统一更新。

$$ \Delta \tau_{ij}^k = \begin{cases} \frac{Q}{d_{ij}} & \text{如果蚂蚁 } k \text{ 经过了路径 } (i, j) \ 0 & \text{否则} \end{cases} $$

蚂蚁密度模型（Ant Density Model）

在蚂蚁数量模型中，蚂蚁在经过路径时留下的信息素为常量。属于局部更新。

$$\Delta \tau_{ij}^k = Q$$

Q 是一个常数。

蚁群算法求解 TSP 问题

旅行商问题，即 TSP 问题（Traveling Salesman Problem），给定一组城市和每对城市之间的距离，商家从其中一个城市出发，要求每个城市都要经过且只能经过一次，最后回到起点城市，求解商家访问这些城市的最短路径。

在经典的 TSP 中，假设所有城市之间都存在路径，即形成一个完全图。也就是说，每对城市之间都有直接的边连接。

完整代码

import logging

logging.info('this is an info msg')
logging.warning('this is a warning msg')

显示时间

要在日志中显示时间信息，可以通过格式字符串 %(asctime)s 控制：

import logging
logging.basicConfig(format='%(asctime)s %(message)s')
logging.warning('is when this event was logged.')

输出结果如下：

2010-12-12 11:41:42,612 is when this event was logged.

按照最新的 Python 3.12.5 official docs， 但一般情况下，我们不需要如此精细的时间。如果需要自定义时间格式，可以通过给 basicConfig 添加 datafmt 参数实现：

import logging
logging.basicConfig(format='%(asctime)s %(message)s', datefmt='%m/%d/%Y %I:%M:%S %p')
logging.warning('is when this event was logged.')

输出结果如下：

12/12/2010 11:46:36 AM is when this event was logged.

关于 datefmt 的格式，参见 time.strftime()。

进阶日志使用

记录器

高级的日志使用方法与基础的区别主要在于模块化记录。关于具体的区别可以参考截止目前最新的 Python 3.12.5 official docs。这里仅对 coding 做出介绍。

一个良好的习惯是：对于不同的模块，使用不同的日志记录器。

import logging
logger = logging.getLogger('example')

对于一个记录器，首先需要指定要处理的 日志级别。需注意，这里指定的是日志处理的最低严重性级别，例如 INFO 表示仅处理 INFO 、 WARNING 、 ERROR 和 CRITICAL 消息，而忽略 DEBUG 消息。

logger.setLevel(logging.INFO)

请注意，setLevel() 是很重要的步骤，如果遗漏，日志级别将被默认置为 NOTEST。这意味着对于一条日志信息：

1. 如果记录器是根记录器时，将处理所有消息
2. 如果记录器不是根记录器，则将委托给父级

这往往会导致一些 exception 出现，因为根记录器默认的日志级别为 WARNING，这意味着你记录的 DEBUG & INFO 日志都不会输出。

处理器

上面说过，对于一个模块，采用一个独立的记录器是合适的。但对于同一个模块，不同类型的日志信息，也许需要不同的处理方式。例如正常的日志信息在 CLI 输出，而异常信息持久化到文件存储，此时就需要对一个日志记录器添加不同的处理器。Python 标准库中已经封装好了许多 常用的处理器类型。下面以 StreamHandler 为例，它可以发送消息到流（一般用于输出到 stdout 或 stderr）。

exp_stream = logging.StreamHandler()
# WARNING > INFO
exp_stream.setLevel(logging.WARNING)

显然，一个记录器添加了若干个处理器后，每个处理器可以设置不同的日志级别。但请注意，上面通过 logger.setLevel(logging.INFO) 已经设置了 logger 的级别。理论上说，handler 的级别应当高于 logger 的级别，因为后者决定了整个模块的日志准入级别，如果 handler 的级别比 logger 更低，会直接被忽略。

格式器

上文“显示时间”章节提到过，可以使用 logging.basicConfig() 来设置日志格式。但这是基于全局的格式控制，用于模块化日志记录显然是不合适的。不同的日志记录器应该可以具有不同的日志格式，这就需要借助格式器来完成。

一种常用的格式如下，这表示 时间 - 记录器名字 - 日志级别 - 日志信息。

formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
exp_stream.setFormatter(formatter)

使用

配置完成后，将 handler 添加到 logger 后，即可像基本使用那样记录日志信息了：

# 添加处理器
logger.addHandler(exp_stream)
# 记录日志
logger.info('this is an info msg')
logger.warning('this is a warning msg')
...

不过，上面示例中的两条日志，只有 WARNING 会被输出，而 INFO 不会。这是因为，只有一个名为 exp_stream 的 handler 被定义处理 WARNING 日志信息，而虽然 logger 的级别是 INFO，但并没有对应的 handler 来处理。

因此，在 Python 的 logging 模块中，默认情况下，如果没有显式地为 logger 添加任何 handler，那么 logger 将不会自动输出任何日志到终端或其他地方。

配置文件

上文的进阶日志使用部分，也可以通过一个日志配置文件统一定义。

有空再写。

FAQ

配置不生效

logging 模块是不支持追加配置的，就是说如果其他部分代码已经使用了 logging.basicConfig()，那么配置就固定了，后续再调用该函数是无法生效的。

安装

Termux-App GitHub

初始化

修改镜像源：

termux-change-repo

屏幕下方的上下左右选中修改 Main Repo，然后在二级菜单中选中 tuna 字样的源（清华源）

使用代理就不需要设置

获取 root 权限（可选）：

su

会弹出授权提示框，允许即可。

安装 ssh 套件：

pkg install openssh

如果安装后使用 ssh 指令报错，请继续安装 openssl

pkg install openssl

安装 vim：

pkg install vim

访问 Android 外置存储：

pkg upgrade
# Android >= 11 务必执行这一步
pkg install termux-am
termux-setup-storage

完成后 ~/ 目录下会多出一个 storage 文件夹，里面有几个软链接，分别链接到相册，下载等路径，其中的 ~/storage/shared 对应 storage/emulated/0/。

修改字体

对于使用了 prompt 的 shell，往往需要额外字体的支持（例如 NerdFont）。下面说明如何更换 Termux 的字体。

1. 下载所需要的字体文件，例如 FiraCode.ttf
2. 将该字体重命名为 font.ttf 并上传到 /data/data/com.termux/files/home/.termux/font.ttf
3. 重启 Termux 或者新建 session 即可生效

注意事项

仅针对 Android 14

1. termux 作为安卓 App，默认只能访问自有路径，即 /data/data/com.termux/files/home，等价于 Linux 下的 /home/user，故显示为 ~。而 / 作为系统根路径，无 root 权限时无法访问。
2. 安卓外置存储，或者说常规模式下用户可以访问的路径，从 /storage/emulated/0 开始，其 shortcut 为 /sdcard

考试范围

• 五个优化算法（遗传、蚁群、粒子群、退火 + 自定义）的基本原理（数学公式，解释清楚）和算法过程（第一步、第二步...），包含老师讲的四个，以及另外一个随便的。15分
• 给出一个用智能优化算法解决本领域的案例
• 给一个问题（他讲过的：退火解决调度问题，粒子群解 TSP 问题，遗传算法解 01 背包），给出智能优化算法求解该问题的过程

遗传算法

基本原理

遗传算法是一种模拟自然进化过程的优化方法，它从一个称为种群的候选解集合开始，通过不断地产生新的种群来寻找更优的解。

遗传算法的核心是选择、交叉和变异三种操作。

• 选择是根据解的适应度来从旧种群中挑选出一些解作为双亲，适应度越高，被选中的概率越大。
• 交叉是将两个双亲的部分特征进行组合，产生新的解作为后代。
• 变异是对某些解的某些特征进行随机改变，增加种群的多样性。

这个迭代产生新种群的过程一直持续到遗传算法达到预设的终止条件为止。这就是遗传算法的基本原理。

对每个个体都进行上述的优化，然后择优录取。

选择、交叉和变异的方式多种多样。以选择为例：

• 轮盘赌法：将个体适应度大小映射为概率进行复制，适应度高的个体有更大概率复制，且复制的份数越多
• 精英产生精英：对适应度高的前 N/4 的个体进行复制，然后用这些个体把后 N/4 的个体替换掉
• 选择个体时，不一定要是有明确指标的，随机的方式也可以
• 甚至不一定总是适应度高的替换低的，用低的随机替换高的也行
• ......

综上所述，给出遗传算法的主要步骤：

1. 产生初始群体。
2. 计算每个个体适应度函数值。
3. 利用轮盘赌算法选择进入下一代群体中的个体。
4. 两两配对的个体进行交叉操作以产生新个体。
5. 新个体进行变异操作。
6. 将群体中迄今出现的最好个体直接复制到下一代中（精英保留策略）。
7. 反复执行步骤 2 到步骤 6,直到满足算法终止条件

遗传算法解 01 背包

代码实现

遗传算法是一种启发式的搜索方法，通常无法保证找到全局最优解。它通过模拟自然选择和遗传变异来逐步改进解，但因为它依赖随机过程，因此每次运行可能会得到不同的结果。为了增加找到最优解的概率，可以多次运行算法，并选择其中最好的结果。

在 01 背包问题中，因为物品本身有 n 种，所以染色体长度设为 n 即可，天然属于二进制编码。

产生初始群体

例如物品列表如下：

那么对于以下两种选择方案：

可分别表示为染色体 A = [110] 和 B = [101]，其中 1 表示选中对应物品。假设背包容量为 40，对于上述两个染色体，A 的适应度就高于 B（因为 value 更大）。

注意：这里的初始种群个数的选择要视具体情况而定，如果初始数量太少可能会导致在向量空间中覆盖面积过小而导致收敛到了非最优解就终止了算法。

选择

1. 计算 n 个物品的适应度值 $f_i$
2. 计算出轮盘赌选择概率 $$ p_i=f_i/\sum f_i=f_i/f_{sum} $$
3. 根据概率选择出下一代种群（注意判断背包容量）

交叉/变异

交叉方式有很多种，这里可以选择一个交叉点位置，然后从此处断开，两者交换即可。变异的话可以随机选择一个点位变异（取反）。

介绍与使用

nvidia-smi，全称为 NVIDIA System Management Interface，是一个跨平台的命令行工具，用于监控和管理 NVIDIA GPU 的状态和性能。它可以显示 GPU 的详细信息，包括型号、驱动版本、内存使用情况、温度、功耗等。此外，它还可以用于控制 GPU 的行为，如调整频率、设置风扇转速等。

在日常的 DL 过程中，应首先关注 GPU 资源的使用情况，否则当资源不足时可能出现 cuda out of memory 等错误。

nvidia-smi 的使用方式就是其本身：

nvidia-smi

显示信息如下：

Fri May 17 16:16:12 2024       
+-----------------------------------------------------------------------------+
| NVIDIA-SMI 470.129.06   Driver Version: 470.129.06   CUDA Version: 11.4     |
|-------------------------------+----------------------+----------------------+
| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |
| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |
|                               |                      |               MIG M. |
|===============================+======================+======================|
|   0  NVIDIA TITAN V      Off  | 00000000:2D:00.0  On |                  N/A |
| 28%   43C    P8    30W / 250W |     16MiB / 12058MiB |      0%      Default |
|                               |                      |                  N/A |
+-------------------------------+----------------------+----------------------+
|   1  NVIDIA TITAN V      Off  | 00000000:99:00.0 Off |                  N/A |
| 28%   42C    P8    24W / 250W |      5MiB / 12066MiB |      0%      Default |
|                               |                      |                  N/A |
+-------------------------------+----------------------+----------------------+
                                                                               
+-----------------------------------------------------------------------------+
| Processes:                                                                  |
|  GPU   GI   CI        PID   Type   Process name                  GPU Memory |
|        ID   ID                                                   Usage      |
|=============================================================================|
|    0   N/A  N/A      2367      G   /usr/lib/xorg/Xorg                 14MiB |
|    1   N/A  N/A      2367      G   /usr/lib/xorg/Xorg                  4MiB |
+-----------------------------------------------------------------------------+

从上至下分为两个表格，先看下面的表格，主要显示占用 GPU 资源的进程信息，从左到右分别为：

• GPU：GPU 编号，与数组下标类似，从 0 开始
• GI ID： GPU 实例 ID（用于 MIG 模式），在非 MIG 模式下为 N/A
• CI ID：计算实例 ID（用于 MIG 模式），在非 MIG 模式下为 N/A
• PID：进程 ID
• Type：进程类型
  • G：表示图形进程
  • C：表示计算进程
• Process name：进程的名称和路径
• GPU Memory Usage：进程占用 GPU 的内存量

[!note] 总结 通常情况下，根据 Processes 表中的信息，即可判断出：谁的哪个进程占用了某张卡的多少资源。还可以在拳头够大友好交流的前提下，根据 PID 杀死该进程。

再来看上面的表格，首先是第一行：

• NVIDIA-SMI：工具版本
• Driver Version：驱动版本
• CUDA Version：Driver API 对应的 CUDA 版本（这是一个略复杂的问题，有空再写）

第二行是表头，的每个格子内分为若干行，每行有若干字段。这个表格的正确读取方式为：每个单词都代表一个独立值。例如第二行第一个格子内实际上有 7 个值，分别为：

• GPU：GPU 编号
• Name：GPU 名称
• Persistence-M：是否开启持久模式
• Fan：GPU 风扇的当前速度百分比
• Temp：GPU 的当前温度（摄氏度）
• Perf：当前的性能状态
  • P8：表示最低功耗状态
  • P0：表示最高性能状态
• Pwr:Usage/Cap：当前功耗和最大功耗（瓦特）

第二行第二列：

• Bus-Id：GPU 在 PCIe 总线上的标识符
• Disp.A：显示设备是否正在使用 GPU（on/off）
• Memory-Usage：GPU 内存使用情况

第二行第三列：

• Volatile Uncorr. ECC：易失性不可纠正错误计数
• GPU-Util：GPU 利用率百分比
• Compute M.：计算模式
  • Default：默认计算模式
  • Exclusive Thread：每个 GPU 只能被一个线程访问
  • Prohibited：禁止使用 CUDA
• MIG M.：多实例 GPU（MIG）模式

Memory-Usage 与 GPU-Util

以上表为例，不难发现 Memory-Usage 存在 GPU 内存占用时，GPU-Util 百分比为 0。

因为当前 GPU 并没有进行计算任务（如深度学习训练或推理），但仍然有内存被分配和占用。

👻幽灵占用

“幽灵占用”问题与上一节类似，主要体现在 Memory-Usage 大量占用，但不仅 GPU-Util 百分比为 0，而且 Processes 表中没有进程或进程占用量与上面显示的不符。

[!tip] “幽灵占用”这名字是我随口起的，不确定这个问题的学名叫什么。。。

这种情况多是由于用户运行了一些自己都不知道是什么玩意的代码，自然也就不知道产生的进程究竟有没有结束，见下图：

针对此类问题，可以尝试以下几步：

# 先查看哪些进程在使用 GPU 设备文件
sudo fuser -v /dev/nvidia*

如果能找到可疑进程，直接根据输出的 PID 杀死即可。

如果这一招也不行，那就采用一个更无脑但有效的方案：

ps aux | grep python

直接找 Python 相关的进程，一个个杀。

介绍

nvitop：交互式的 NVIDIA-GPU 监控。略多版介绍可见 上海交大超算平台用户手册-nvitop。

部署

请务必使用 root 权限进行全局安装，否则会被安装到 conda 隔离环境中。

sudo pip3 install --upgrade nvitop

参数列表

[!tip] 只列出的部分常用参数，具体见官方文档，或者 nvitop --help

可选参数:
  --help, -h            帮助文档
  --version, -V         查看版本号
  --once, -1            只显示一次信息
  --monitor [{auto,full,compact}], -m [{auto,full,compact}]
                        持续监控,如果省略-m参数,默认采用auto
  --interval SEC        进程状态更新间隔(单位: 秒) (默认: 2s)

颜色:
  --colorful            使用渐变色显示条形图
  --light               使用亮色主题显示(NVITOP_MONITOR_MODE="light")

设备过滤:
  --only idx [idx ...], -o idx [idx ...]
                        只显示指定设备
  --only-visible, -ov   只显示 `CUDA_VISIBLE_DEVICES` 环境变量对应的设备

进程过滤:
  --compute, -c         显示具有计算上下文的GPU进程 (type: 'C' or 'C+G')
  --only-compute, -C    显示只具有计算上下文的GPU进程 (type: 'C' only)
  --graphics, -g        显示具有图形处理上下文的GPU进程 (type: 'G' or 'C+G')
  --only-graphics, -G   显示只具有图形处理上下文的GPU进程 (type: 'G' only)
  --user [USERNAME [USERNAME ...]], -u [USERNAME [USERNAME ...]]
                        显示指定用户的进程 (or `$USER` for no argument).
  --pid PID [PID ...], -p PID [PID ...]
                        显示置顶PID的进程

快捷键

默认情况下，调用 nvitop 会进入 monitor 模式，类似于 top，而 nvitop -1 才是与原版 nvidia-smi 类似的单次显示。

在 monitor 模式下，存在一些快捷键：

太多了，只摘取了一些常用的，懒得翻译了，就这样吧

sparrow search algorithm

XUE J, SHEN B. A novel swarm intelligence optimization approach: sparrow search algorithm[J]. Systems Science & Control Engineering, 2020, 8(1): 22-34.

Abstract

[!quote] 受麻雀群体智慧、觅食和反捕食行为的启发，本文提出了一种新的群体优化方法，即麻雀搜索算法（SSA）。在19个基准函数上进行了实验，测试了SSA的性能，并将其与灰狼优化器（GWO）、引力搜索算法（GSA）和粒子群优化（PSO）等其他算法的性能进行了比较。仿真结果表明，所提出的SSA在精度、收敛速度、稳定性和鲁棒性方面优于GWO、PSO和GSA。最后，通过两个工程实例验证了所提出的SSA的有效性。

Introduction

1. 受麻雀种群觅食和反捕食行为的启发，提出了一种新的SI技术，即SSA；
2. 通过使用所提出的SSA，在一定程度上提高了优化搜索空间的探索和利用率；
3. 所提出的SSA在两个实际工程问题中得到了成功的应用。

Biological characteristics

麻雀通常是群居鸟类，种类繁多。它们分布在世界大部分地区，喜欢生活在人类生活的地方。此外，它们是杂食性鸟类，主要以谷物或杂草的种子为食。众所周知，麻雀是常见的留鸟。与许多其他小鸟相比，麻雀非常聪明，记忆力也很强。请注意，有两种不同类型的圈养麻雀，既有生产者，也有觅食者。生产者积极寻找食物来源，而觅食者则由生产者获取食物。此外，有证据表明，鸟类通常灵活地使用行为策略，并在生产和觅食之间切换。也可以说，为了寻找食物，麻雀通常使用生产者和觅食者的策略。

研究表明，个体会监控群体中其他人的行为。同时，鸟群中的攻击者想要提高自己的捕食率，他们被用来与高摄入量的同伴争夺食物资源。此外，当麻雀选择不同的觅食策略时，个体的能量储备可能会发挥重要作用，而能量储备低的麻雀会觅食更多。值得一提的是，这些位于种群边缘的鸟类更容易受到捕食者的攻击，并不断试图获得更好的位置。位于中心的动物可能会向邻居靠近，以尽量减少其危险范围。我们也知道，所有的麻雀都表现出对一切事物好奇的本能，同时它们总是保持警惕。例如，当一只鸟确实探测到捕食者时，一个或多个个体发出啁啾声，整个群体就会飞走。

Mathematical model and algorithm

根据之前对麻雀的描述，我们可以建立数学模型来构建麻雀搜索算法。为了简单起见，我们将麻雀的以下行为理想化，并制定了相应的规则：

1. 生产者通常拥有高水平的能量储备，并为所有觅食者提供觅食区域或方向。它负责确定可以找到丰富食物来源的地区。能量储备的水平取决于对个体适应度值的评估。
2. 一旦麻雀发现捕食者，个体就会开始鸣叫，发出警报信号。当警报值大于安全阈值时，生产者需要将所有搜寻者带到安全区域。
3. 只要寻找更好的食物来源，每只麻雀都可以成为生产者，但生产者和觅食者在整个种群中的比例没有变化。
4. 能量较高的麻雀将充当生产者。为了获得更多的能量，一些饥饿的觅食者更有可能飞往其他地方觅食。
5. 觅食者跟随能够提供最好食物的生产者寻找食物。与此同时，一些觅食者可能会不断监视生产者并争夺食物，以提高自己的捕食率。
6. 处于群体边缘的麻雀在意识到危险时迅速向安全区域移动以获得更好的位置，而处于群体中间的麻雀则随机行走以靠近他人。

在模拟实验中，我们需要使用虚拟麻雀来寻找食物。麻雀的位置可以用以下矩阵表示：

其中 n 是麻雀的数量，d 表示要优化的变量的维度。那么，所有麻雀的适应度值可以用以下向量表示：

其中 n 表示麻雀的数量，$F_X$ 中每一行的值表示个体的适应度值。在SSA中，具有更好适应度值的生产者在搜索过程中优先获得食物。此外，因为生产者负责寻找食物和引导整个“鸟口”的流动。所以，生产者可以在比觅食者更广泛的地方寻找食物。根据规则（1）和（2），在每次迭代过程中，生产者的位置更新如下：

其中t表示当前迭代，$j=1,2,...,d.X^t_{i,j}$表示迭代t时第i个麻雀的第j个维度的值。$iter_{max}$是迭代次数最多的常数。$\alpha \in (0,1]$是一个随机数。$R_2 \in [0,1]$和$ST \in [0.5,1.0]$分别表示报警值和安全阈值。Q 是服从正态分布的随机数。L表示$1 \times d$ 的矩阵，其中内部的每个元素都是1。

当$R2 \lt ST$时，这意味着周围没有捕食者，组群会逐渐聚集，如下图。如果$R2 \ge ST$，则意味着一些麻雀已经发现了捕食者，所有麻雀都需要迅速飞往其他安全区域，即按正态分布随机移动到当前位置附近。

至于觅食者，他们需要执行规则（4）和（5）。如上所述，一些觅食者更频繁地监视生产者。一旦他们发现生产者找到了好的食物，他们就会立即离开目前的位置去争夺食物。如果他们赢了，他们可以立即获得生产者的食物，否则他们将继续执行规则（5）。觅食者的位置更新公式如下所述：

其中$X_P$是生产者所占据的最佳位置。$X_{worst}$表示当前全局最差位置。A 表示一个 $1 \times d$ 的矩阵，其中每个元素随机分配1或−1，$A^+=A^T(AA^T)^{-1}$。当$i \gt n/2$时，这表明适应度值较差的第 i 个觅食者最有可能正在挨饿。

[!quote] 从公式可以看出，若i>n/2时，其值为一个标准正态分布随机数与一个以自然对数为底数的指数函数的积，当种群收敛时其取值符合标准正态分布随机数。 (其值会收敛于0)。

若i<=n/2时，其取值为当前最优的麻雀的位置加上该麻雀与最优位置每一维距离随机加减后，将总和均分到每一维上。过程可以描述为在当前最优位置附近随机找一个位置，且每一维距最优位置的方差将会变得更小，即不会出现在某一维上与最优位置相差较大，而其他位置相差较小。（其值收敛于最优位置）。

[!tip] 在麻雀搜索算法中，觅食者是指除了生产者（producer）之外的其他麻雀。在觅食者位置更新的逻辑中，(i > n/2) 和 otherwise 分别对应了两种情况，表示了觅食者在更新位置时的不同策略：

1. 当 (i > n/2) 时：这表示觅食者的编号 (i) 大于种群大小 (n) 的一半。在这种情况下，觅食者更倾向于向生产者靠近，以便更好地利用生产者的信息和种群中心的指引。因此，觅食者在更新位置时会采取更加向种群中心和生产者靠拢的策略，以加速搜索过程。

2. 当 (i <= n/2) 时（即 otherwise）：这表示觅食者的编号 (i) 小于等于种群大小 (n) 的一半。在这种情况下，觅食者可能更倾向于探索种群中的其他区域，而不是过于依赖生产者和种群中心的信息。因此，觅食者在更新位置时可能会更多地进行探索，以寻找潜在的更优解。

总体逻辑是，在麻雀搜索算法中，觅食者根据自身的编号与种群大小的关系，调整其更新位置的策略。这种策略旨在平衡利用生产者和种群中心的信息，同时保持一定的探索性，以更有效地搜索解空间中的潜在解。

侦查预警行为

在模拟实验中，我们假设这些意识到危险的麻雀占总种群的10%到20%。这些麻雀的初始位置是在种群中随机产生的。根据规则（6），该数学模型可以表示如下：

其中$X_{best}$是当前的全局最优位置。$\beta$是步长控制参数，$\varepsilon$ 是一个平均值为0且方差为1的服从正态分布的随机数。$K \in [−1, 1]$是一个随机数。这里 $f_i$ 是当前麻雀的适应度值。$f_g$和$f_w$分别是当前全局最佳和最差适应度值。$\epsilon$是最小的常数，以避免零除法误差。

为了简单起见，当$f_i \gt f_g$表示麻雀处于组的边缘时。$X_{best}$代表种群中心的位置，在它周围是安全的。$f_i = f_g$表明，处于种群中间的麻雀意识到了危险，需要靠近其他麻雀。$K$表示麻雀移动的方向，也是步长控制参数。

[!tip] 关于 $f_i, f_g$ 大小关系的含义 在麻雀搜索算法中，$f_i$表示第$i$只麻雀的适应度值，$f_g$表示种群中适应度值最高的麻雀的适应度值。

当某只麻雀的适应度值$f_i$大于种群中适应度值最高的麻雀的适应度值$f_g$时，这意味着该麻雀的适应度比整个种群中的其他麻雀都要高，因此该麻雀被认为处于种群的边缘，即在搜索空间中处于一个比较优越的位置，可能是一个局部最优解或者接近全局最优解。

当某只麻雀的适应度值$f_i$等于种群中适应度值最高的麻雀的适应度值$f_g$时，这表示该麻雀的适应度与整个种群中适应度最高的麻雀的适应度相同，即达到了种群的最高适应度水平。在这种情况下，可以理解为中心麻雀意识到了危险，因为虽然它的适应度与种群中最好的麻雀相同，但仍然可能存在更好的解决方案，因此需要继续搜索以寻找可能的更优解。

基于上述模型的理想化和可行性，SSA的基本步骤可以概括为算法1中所示的伪代码。

应用

WANG J, HAO S, ZHAO G. CSSA-based collaborative optimization recommendation of users in mobile crowdsensing[J]. PEER-TO-PEER NETWORKING AND APPLICATIONS, 2023, 16(2): 803-817.

Abstract

移动人群感知（MCS）作为一种新的感知范式，将人工智能与物联网相结合，利用具有智能设备（包括手机、智能汽车、可穿戴设备等）的移动用户来执行任务请求者请求的感知任务。移动用户固有的移动性使移动众感成为一个通用的平台，可以取代或补充现有的静态感知基础设施[1]。通过这种数据采集，MCS在交通监测[2]、环境现象观测[3]、移动医疗[4]等领域发挥着举足轻重的作用。传感系统由平台、任务发布者和参与者用户三部分组成。

任务发布者可以是一台机器，也可以是一个人。参与感测任务需要参与者的时间以及设备的感测、计算和通信资源。为了刺激广泛的用户参与，一些MCS系统为用户提交的有价值的传感器报告提供奖励[5]。激励可以采取不同的形式[6]，包括金钱、通过游戏获得的娱乐或系统提供的服务。这些任务预算分配给根据传感数据花费的时间或提供的传感报告的质量完成传感任务的参与者[7]。因此，为了提高感知任务的数据质量[8，9]并降低任务成本[10-12]，选择合适的用户是一个非常重要的先决条件。

移动人群感知系统通过用户参与任务，利用移动感知设备采集上传到平台的数据，完成数据采集。如何正确的用户，对于完成整个任务有着关键的影响。在之前的任务分配中，用户选择过程是通过分析用户属性与任务之间的匹配度来完成的。通常主要目标是提高感知数据的质量，用户选择基于可信用户选择[13]、质量推理方法[8]、用户信息质量分析[14]等方法。这些方法适用于收集单一数据类型的感知任务。当传感任务需要各种传感数据时，例如城市环境的数据收集，包括温度、湿度、图像和其他信息，并且用户设备上的传感器类型不同。与数据采集位置的距离不同，因此很难找到多个合适的用户来完成任务。

面对复杂的任务需求，仅考虑单个用户选择的优化很难满足需求。简单地增加具有相似属性的用户数量不仅会增加成本，还会造成数据冗余。因此，针对在这种复杂环境中寻找最优用户选择方案的问题[15]，本文提出了一种新的感知任务用户选择框架——群感知麻雀搜索算法（CSSA）。分析了用户属性与任务之间的拟合程度，如图1所示。通过多个用户之间的协作，由他们自己的传感设备收集不同的数据，共同完成传感任务。为了解决复杂环境中的优化问题，智能优化算法中的麻雀搜索算法（SSA）[16]被用于解决该问题。该算法具有搜索精度高、收敛速度快、稳定性强的特点。

本文的贡献如下：

1. 本文考虑了用户不同因素对任务的影响，提出了用户适应度的概念，通过计算用户的位置、设备状态和用户的历史信誉[17]，分析了用户与任务的匹配程度、用户上传数据的质量可靠性，并根据对用户对任务优先级的分析，认为影响因素越全面，结论越可靠。
2. 本文提出的方法是基于麻雀搜索算法。利用用户的适应度来划分用户的身份，然后通过混沌序列映射来初始化用户群体。模拟了麻雀搜索算法的迭代优化过程，求解了最优用户选择方案。与其他群智能优化算法相比，它具有优化能力强、收敛速度快的优点。
3. 基于任务所需的不同类型的感知数据，采用了多用户协作的方法。每个用户使用当前设备的传感器收集传感数据，然后将多个用户上传的信息进行整合，完成传感任务。与非合作用户相比，结果数据质量更高。

Related work

任务分配是MCS的一个主要研究方向。它收集来自移动用户的感知数据，并获得感知结果以完成任务。一般来说，影响任务质量的因素有很多，包括数据收集量、任务持续时间和任务空间-时间覆盖率[18]。收集的传感器数据越多，任务的质量就越高。适当的任务空间-时间覆盖通常也意味着更高的任务质量。影响任务成本的因素还有很多[19]，包括用户招募成本、用户移动成本和数据传输成本。

本文的用户推荐方法综合考虑了以上三个方面。用户的信息分为位置、权力、信誉等，通过多方面的信息综合考虑用户，确保任务的数据质量。并通过用户设备传感器类型和任务匹配程度来满足任务数据类型的各种需求。与以前的任务分配方法相比，CSSA方法更适合于需要多种数据类型的复杂情况。此外，根据群体智能优化算法。

Problem description

由于现有的研究方法侧重于单一类型的感知数据收集，在面对复杂的任务要求时效果并不理想。而且，面对复杂的任务需求，仅考虑单个用户选择的优化很难满足需求。简单地增加具有相似属性的用户数量，不仅会增加任务成本，还会造成数据冗余。

为了解决这个问题，本文提出了一个用户选择框架，该框架综合考虑了各种用户属性对任务感知数据质量的影响以及多用户协作问题。该策略的目标是在确保任务成本的同时提高感知数据的质量，同时考虑用户选择的时间。本文将用户对任务的影响因素主要归结为以下几个方面：用户与数据采集地点的距离；用户设备的传感器类型与任务所需的感测数据类型之间的一致程度；感测装置的剩余功率；基于历史数据的用户信誉。

由于待解决问题的复杂性很高，针对上述影响因素提出了适合度的概念，并以适合度值作为衡量用户优先级和匹配度的参考。适合度计算所需的信息包括用户通过定位的位置信息、用户设备上传的设备剩余电量和传感器类型信息，以及基于用户历史任务完成记录获得的信誉信息。通过对这些值的计算，完成了对采集到的任务数据的质量控制，分析用户是否适合当前任务。这些适应度值是智能优化算法的重要参考标准，如图2所示。

移动众感知平台由许多感知用户组成。U表示任务发布时可以参与系统的用户集合，$F=(f_1, f_2, f_3, f_n)$ 表示当前所有用户对该任务的适应度值，用户集为$U = (u_1, u_2, u_3, u_n)$ 的顺序。按比例将用户分为探索者（初级传感数据采集任务适应度高）和跟随者（适应度低，负责补充数据和改进传感数据类型），并分别根据不同的职责进行任务感知。最后，根据CSSA算法筛选出合适的感知用户。

基于上述用户选择模型，在考虑数据质量、任务成本和分配时间的前提下，将数据质量最大化的用户选择问题定义如下：

其中 $I$ 是$1 \times j$的全1矩阵，用于控制所有用户传感器类型的总和以满足任务所需的类型，其中$j$是任务所需类型的数量。$d_i$是用户和任务感知位置之间的距离，通过选择靠近用户的位置，从而降低成本。$UserSen_i \cap TaskSen_i \ne \emptyset$确保用户的设备类型满足至少一个任务要求。目标函数V是表示用户通过设备的剩余功率和设备的适合度来完成任务的数据质量，然后通过乘以信誉适合度来表示最终的完成效果。

同时，为了提高用户选择效率和数据质量，本文采用参与者协作的方式来完成任务。分析当前任务所需的数据类型，并要求用户根据不同的传感器完成他们可以提供的信息类型。然后，平台对多个用户上传的内容进行汇总分析，完成传感数据的采集。该算法利用了群体间协作的特点，有利于移动众感知中参与者和用户群体的协作，完成感知任务。同时，综合分析感知用户与用户的位置、设备等多个属性的匹配程度。在众感中，通过分析多种影响因素的用户选择策略和用户之间的合作，可以提高感知数据的质量和任务分配时间，并显著提高众感平台的性能。表1总结了本文中使用的重要符号。

User collaborative recommendation method

Calculation of user fitness value

Position fitness

通过计算任务位置与用户的匹配关系，当用户远离任务时，用户需要移动的距离会增加，从而增加任务完成时间和更高的任务成本。鉴于这种情况，本文引入了位置适合度的概念，并将用户和任务之间的距离作为衡量适合度的指标进行了比较。计算公式如下：

其中$d_{max}$是所有用户与任务之间的最大距离，$d_i$是用户$i$与任务之间距离。根据公式（1）的计算，用户与任务之间的距离越小，位置适应度越大；当用户和任务之间的距离变长时，适合度逐渐降低。当适应度等于1时，它达到最大值，这意味着用户接近任务。从位置的角度来看，用户具有最高的优先级。上述公式将用户与任务之间的位置关系转换为距离，其中欧几里德距离用于计算用户ui与任务s之间的距离，用户的位置为（xi，yi），任务的位置为为（x，y），公式如下：

原来路径任务在用户感知区域时，随着任务之间的距离越来越近，用户与任务之间的适应度位置也会提高，用户想要执行的任务意图越来越大。因此用户可以主动加快速度，减少移动时间，降低任务完成的速度，提高整体效率。

Electric quantity fitness

电量适合度被认为是移动设备的剩余电量，因为在完成任务的过程中，传感器的感知数据需要不断利用，感知数据需要通过通信网络实时上传到平台。这个过程需要不断消耗移动设备的电量。因此，电量适合度也是一个重要的考虑参数，它决定了移动设备是否有能力完成感知数据收集。当电量较低时（根据调查，当设备电池电量低于30%时，用户参与任务的意愿非常低，因此本文将电量设置为30%），用户很可能不愿意参与任务。电量适应度的计算根据电量剩余百分比[0,1]中的数据表示，公式如下：

其中$CE_i$和$E_i$分别表示当前用户的设备的剩余可用功率和总功率。

Equipment fitness

根据任务需要感知的数据类型不同，对感知用户设备的要求也不同。因此，需要考虑候选参与者的传感设备上所需传感器的可用性，这将显著影响数据的可靠性和传感结果的质量。在不同要求的传感任务中，每个人的设备都必须配备所有必要的传感器，当一些必要的传感器缺失时，平台会认为这些用户没有资格选择。本文列出了一些可能的传感器，如表2所示。然而，由于用户2的信号质量较低，数据上传过程可能不稳定，从而影响任务的数据质量。因此，采用用户合作的方法，由多个用户收集不同类型的数据，并合作完成感知任务。例如，用户3和用户5分别具有位置传感器和温度传感器，并且具有更高的信息质量，因此可以通过用户之间的合作更好地完成感知任务。为了量化匹配程度，使用设备适应度来表示用户和任务之间的硬件能力匹配程度，并将任务依次分配给最好的用户，这不仅可以降低任务所需的成本，还可以提高数据质量。设备信息与传感内容的匹配程度如图3所示。

其中$SameSen_i=UserSen_i \cap TaskSen$是传感器重组集，表示用户设备的传感器类型集与任务感知内容集的重叠部分。其中一些是必不可少的传感器，其他非关键类型的传感器越来越好，因此传感器的符合度为：

其中$Sig_i$和$Sig_{max}$分别表示设备当前信号质量和最高信号质量，并以分数的方式分析用户当前信号质量强度。$SameSen_i$和$TaskSen$的比值表示当前设备类型与任务需求类型之间的拟合程度。$\eta_1$是信号强度系数，$\eta_2$是传感器符合度系数，两者之间的关系为$\eta_1 + \eta_2 = 1$，控制着不同变量的权重。

然而，每个感知用户不需要拥有所需的所有感知传感器类型，而是可以通过多个用户之间的合作来完成多种类型感知数据的收集。如上所述，用户3和5一起工作以获得比单独的用户2更好的结果。因此，1×j的矩阵Mi用于记录当前用户i的传感器类型，j是任务所需的传感器类型。用户携带的设备所拥有的传感器类型设置为1，如果没有传感器，则设置为0。

Reputation fitness

由于声誉本身很难直接评估，因此用户的声誉[38]是基于他们之前参与感知任务来评估的。评估标准包括他们是否致力于完成分配给他们的任务以及完成这些任务的能力。以下公式（7）和（8）分别用于评估每个参与者的信誉参数：

其中Spti表示用户参与的任务集，Cti表示用户被选择的任务集；比率Cti表示用户将参与该任务的概率；Scti表示用户完成的一组任务，Fti表示由用户完成的任务集，比率Scti表示用户完成任务的概率。由于这两个参数相对不同，因此使用它们的集合平均值来给出参与者的总体声誉。因此，每个用户的个人信誉适合度由以下公式计算：

因此，根据上述方法，每个用户的适应度计算如下：

根据感测服务的性质，可以给予某个参数比其他参数更高的权重。

Selection of sensing users

当感知任务发布时，愿意参与任务的感知用户向平台报告，参与者集为U=（u1，u2，u3…un）。平台首先根据用户属性和历史数据，通过公式（8）计算出每个用户的（信誉？）适应度 Fi。

初始化所有用户在优化算法中的位置。为了提高算法的全局搜索能力，避免迭代后期种群多样性的降低，采用逻辑混沌映射代替随机数生成，使位置更加随机、规则。公式如下：

其中μ是Logistic参数，当μ的值满足3.5699456<μ<=4的条件时，迭代生成的值处于伪随机分布状态。通过上述公式的迭代计算，n个参与者在维度d下的位置由矩阵表示：

参与者的适应度值可以表示为：

其中n表示参与者的数量，d表示优化变量的维度。通过计算上述矩阵，按适合度值对用户进行排序，并通过设置值$P_r$将用户划分为探索者和追随者的两种不同身份，$P_r$表示探索者占所有参与者的比例。当前用户由数组 ID[n]标识，0表示follower，1表示explorer。其中，探索者由于任务适应度高，负责主要的传感数据采集，是传感任务的主要成分。追随者与探索者的身份相对应。

由于适应度低，追随者跟随探索者收集数据，并负责补充数据和改进传感数据类型。例如，当Pr设置为0.2时，探索者与跟随者的比例为2:8。探索者的位置更新如下：

其中t表示当前迭代次数，$j=1,2,...,d$表示当前维度，$U^t_{i,j}$表示迭代t时第i个感知用户的第j个维度的位置，$iter_{max}$是迭代次数最多的常数。$\alpha \in (0,1)$是一个随机数，$P_n \in [0,1]$和$CT \in [0.5,1.0]$分别表示子区域的任务完成度和完成阈值。Q是遵循正态分布的随机数。

当 $P_n \lt CT$ 时，表示当前区域的任务完成次数未达到阈值，当前搜索者可以继续完成子区域的任务。当使用$P_n \ge CT$时，意味着当前区域的参与者数量满足任务完成的要求，所有探索者都需要完成其他子区域的感知任务。

跟随者跟随在探索者附近，负责部分传感数据的收集，随着探索者完成任务，两者的适应度值会动态变化，当跟随者发现探索者的适应度低于自己时，他们会产生竞争关系，两者的身份也会发生变化，当前用户ID[i]的值也会发生反转。职位更新公式如下：

其中$U_p$是探索者最佳位置，$U_{worst}$是全局最差的位置。D表示维度值。当跟随者的适应度值合适时，移动到当前探险家的位置附近，随机到最佳位置附近的位置，距离最佳位置的每个维度的方差变小；当 $i \gt n/2$时，这表明跟随者在当前感知用户队列中的适应度值非常低，无法完成当前任务，然后在其他区域中寻找感知任务。

此外，所有任务参与者中的一部分被选为监控器，这些监控器在人群中随机生成，负责防止用户集中在最佳感知位置并陷入局部最优。选择10%~20%的感应用户作为监视器，其位置表达式更新如下：

其中$U_{best}$和$U_{worst}$分别表示当前全局最优位置和最差位置；$\beta$作为步长控制参数，是一个平均值为0、方差为1的正态分布随机数；$f_i$是当前个体用户的适应度值；$f_g$是当前的全局最优适应度值。为了避免陷入局部最优，如果用户处于最佳位置，他应该逃到最佳位置和最差位置之间的随机位置；否则，他应该逃到他自己和随机位置之间的随机位置。

优化算法的目的是找到目标函数的最大值，即找到最符合任务要求的用户，从而提高数据质量。

Experimental results and analysis

模拟实验的数据来自Geolife[39]数据集，该数据集包含182个用户的GPS轨迹，由一系列时间戳表示。每个点包含经度、纬度和高度的坐标信息，包括17621个轨迹。本文主要使用经纬度坐标信息。传感器的可用类别由用户携带，剩余功率等随机分配给用户。

为了使实验结论更加可靠，本文还使用真实的数据集进行验证，通过众包平台“猪八戒”上的数据采集工具进行抓取，筛选出交易记录最多的前200名用户。每个传感用户的信息包括位置、价格、历史完工数据和其他信息。本文使用的仿真工具是MATLAB，它是在Windows10的64位平台上实现的。处理器为AMD R7-4800 h，主频为2.9 GHz，内存为16.00 GB。

在本文中，首先使用测试函数来调整算法。调整ED和CT两个参数以优化算法的优化性能，并通过1000次迭代获得最快的迭代率。如图4、5、6和7所示，区域完成度阈值设置为0.8，迭代次数设置为1000，以调试探索者和跟随者的比例。图4和图5中探索者和追随者的比例分别为0.2:0.8和0.3:0.7。当任务中探索者的比例增加时，迭代速度略慢，但在有限的迭代次数中，适应度值的准确性显著提高。因此，适当增加探索者在参与者群体中的比例有利于提高算法的性能。

当探索者和跟随者的数量之比固定为0.3:0.7时，设置区域完成阈值，如图6和图7所示。在完成阈值降低后，迭代曲线在快速下降后将呈现出明显的平坦期。由于任务完成设置的程度降低，参与者可能会重复改变感知区域，导致适应度准确性在一段时间内几乎没有提高，从而降低任务完成效率。图6和图7中转换曲线的比较表明，完成阈值设置得越低，曲线的平坦化周期就越长。经过反复测试，发现0.8的完成阈值CT表现最好。因此，ED参数设置为0.3，CT参数设置为0.8。

背景

经查，由于上游服务商相关政策，针对免费 ssl 的有效时间从 1 年缩减至了 90 天，国内腾讯云及阿里云等平台均受影响。

如此一来，这些云服务大厂的免费证书按照麻烦程度真的不如 acme.sh 签 90 天的泛域名了。不过不知道处于什么原因，腾讯跟阿里都是有云计算平台的 CLI 工具的，但搜索了一圈发现只有阿里云平台的第三方教程，而腾讯云的大多是调用的 web api，所以这里就自己折腾一下吧。

官方的文档只能当手册看，拿来当教程用略有些折磨。

安装 TCCLI

以下内容节选自官方文档，由于文档链接可能会变动，这里就不放了，反正它们钱多，搜索引擎排名向来都是“名列前茅”的，所以随便搜一搜就有了。

TCCLI 没有独立的二进制文件，需要一来 Python 环境，所以安装也是依靠 pip 进行：

pip install tccli

查看是否安装成功：

tccli --version

3.0.1099.1

在 Linux 环境下执行以下命令可开启自动补全功能，支持大小写自动纠错：

complete -C 'tccli_completer' tccli

将其写入 .bashrc/.zshrc 可持久化生效。

配置 TCCLI

通过交互模式进行配置：

tccli configure

由于安全原因，不建议为腾讯云主账户设置 API Token，通常是建立子用户来设置权限，使用子用户的 secrectKey/Id 进行操作。因此，这里建议使用 TCCLI 的多账户模式：

tccli configure --profile any_name_you_like

后续使用 tccli 指令时，在最后加上 --profile any_name_you_like 即可使用对应的账户配置。

上传证书

tccli ssl UploadCertificate --cli-unfold-argument --CertificatePublicKey '-----BEGIN CERTIFICATE-----
***
-----END CERTIFICATE-----' --CertificatePrivateKey '-----BEGIN EC PRIVATE KEY-----
***
-----END EC PRIVATE KEY-----' --Alias 'acme-085404.xyz'

响应结果：

{ 
    "Response": {
        "CertificateId": "***", 
        "RepeatCertId": "", 
        "RequestId": "***" 
    }
}

这里的 CertificateId 就是腾讯云控制台的证书 id。

更新 CDN 证书

tccli cdn UpdateDomainConfig --cli-unfold-argument --Domain 'blog.085404.xyz' --Origin.AdvanceHttps.CertInfo.CertId LE-dsfdsf --Origin.AdvanceHttps.CertInfo.Certificate '不展示' --Origin.AdvanceHttps.CertInfo.PrivateKey '不展示' --Origin.AdvanceHttps.CertInfo.Message '备注' --Origin.AdvanceHttps.CertInfo.From 'acme.sh-upload'

#!/bin/bash

tccli cdn ModifyDomainConfig --cli-unfold-argument --Domain 'blog.085404.xyz' --Route 'Https.CertInfo.CertId' --Value '{\"update\":\"0VpOXiPz\"}'

echo "cdn证书更新脚本执行完成"

脚本示例

使用下述脚本前，先执行 sudo apt install jq，需要 jq 这个库来解析命令行输出的 json 数据。

你用 sed 当然也行

#!/bin/bash

# 读取acme.sh证书，并上传腾讯云，返回证书id

# 从文件中读取文本内容并存储到变量中
SSLPub=$(cat "/root/.acme.sh/085404.xyz_ecc/fullchain.cer")
SSLPri=$(cat "/root/.acme.sh/085404.xyz_ecc/085404.xyz.key")

response=$(tccli ssl UploadCertificate --cli-unfold-argument --CertificatePublicKey "$SSLPub" --CertificatePrivateKey "$SSLPri" --Alias "acme-085404.xyz" --profile obsidian)

echo $response

CertificatedId=$(echo $response | jq -r '.CertificateId')

echo "cerd id: $CertificatedId"
cert_id='{"update":"'$CertificatedId'"}'

tccli cdn ModifyDomainConfig --cli-unfold-argument --Domain 'your_cdn_domain.com' --Route 'Https.CertInfo.CertId' --Value "$cert_id" --profile obsidian

前情提要

最近被学弟安利了一个开源项目 ServiceLogos，是一个各类开发语言与 IDE 的 Logo 设计仓库。

所以想了想，老登也要跟上时代！美化的尽头是默认，但首先要开始美化😁

插件安装

众所周知，VSCode 的本质就是一个浏览器 IDE，你可以在里面写代码、看动漫、看小说，而这些的前提都是基于各种各样的插件。因此，首先安装以下两个插件：

名称: Custom CSS and JS Loader
ID: be5invis.vscode-custom-css
说明: Custom CSS and JS for Visual Studio Code
版本: 7.2.1
发布者: be5invis
VS Marketplace 链接: https://marketplace.visualstudio.com/items?itemName=be5invis.vscode-custom-css

名称: Background
ID: Katsute.code-background
说明: The most advanced background image extension for VSCode
版本: 2.10.2
发布者: Katsute
VS Marketplace 链接: https://marketplace.visualstudio.com/items?itemName=Katsute.code-background

美化设置

背景

Ctrl + Shift + P，搜索 Background: Configuration，有四个组件的背景可以设置：

1. Window（整个窗口）
2. Editor（编辑器）
3. Sidebar（侧边栏）
4. Panel（各种弹出窗口）

选中你要修改的组件，然后选择一张图片即可。

Logo

Ctrl + Shift + P - Open User Settings

在 settings.json 中插入一行：

"vscode_custom_css.imports": ["file:///D:/snippets/vscode-custom/logo.css"]

这里的 file:/// 是文件协议，指向你的自定义 css 文件，该文件如下：

.editor-group-watermark > .letterpress{
  background-image: url("image.link") !important;
  opacity: .75;
  aspect-ratio: 3/2 !important;
}

将其中的 image.link 替换为 Logo 图片的链接，可以是 ServiceLogos 中的 raw link，也可以将图片转为 base64 后替换进去。如果网络环境无法直连 github，建议选择 base64 方案。

最终效果

JupyterHub is the best way to serve Jupyter notebook for multiple users. Because JupyterHub manages a separate Jupyter environment for each user, it can be used in a class of students, a corporate data science group, or a scientific research group. It is a multi-user Hub that spawns, manages, and proxies multiple instances of the single-user Jupyter notebook server.

前置环境

安装 Python 和 pip

大多数发行版 Unix 系统都自带 python 和 pip：

apt install python3 python3-pip

注意这里用 pip3 -V 看一下版本。太老的版本（例如 python 3.6）基本是会出问题的。所以如果需要更新 pip3：

sudo -H pip3 install -U pip

如果提示 Cache entry deserialization failed, entry ignored，可能是由于某些缓存文件损坏或不完整所致。这个问题通常可以通过清理 pip 的缓存来解决：

pip3 cache purge

如果你的 pip3 版本太老，也可能提示 ERROR: unknown command "cache" - maybe you meant "check"，那就只能手动清楚缓存了：

# Linux下的pip缓存通常在 `~/.cache/pip` 或 `/var/cache/pip`
rm -rf ~/.cache/pip
rm -rf /var/cache/pip

然后重新执行 sudo -H pip3 install -U pip。

安装 JupyterHub

sudo -H pip3 install -U jupyterhub

• -H 选项告诉 pip 使用 HOME 环境变量指定的目录作为家目录。这在使用 sudo 时很重要，因为默认情况下，sudo 会重置 HOME 环境变量为 /root。使用 -H 选项可以确保 pip 将包安装到当前用户的家目录下，而不是 root 用户的家目录下。这样做是为了避免因为权限问题导致的包安装到错误的位置。
• -U 选项是 pip 的一个标志，代表 --upgrade。它告诉 pip 安装包之前先尝试升级已安装的包到最新版本。如果已经安装了某个包，-U 选项会使 pip 尝试升级到新版本，如果没有指定包，则会安装最新版本。

安装 configurable-http-proxy

这是一个 nodejs 模块，npm 安装的（官方要求的）。理论上说，安装 nodejs 用 apt install 就行。不过版本实在太老了，所以还是建议手动 install 吧，反正也不费什么事。

npm install -g configurable-http-proxy

去官网找契合操作系统版本的 Node.js LTS 版本即可。

配置 JupyterHub

基于 JupyterHub version 2.3.1。移除网络上抄来抄去的过时配置。

生成默认配置文件 并移动到公共目录：

jupyterhub --generate-config
mkdir -p /etc/jupyterhub
mv jupyterhub_config.py /etc/jupyterhub/

可能会报错 python 版本不受支持之类的，可以忽略不用管。

接下来修改配置文件：

# 使用 JupyterLab 而非 Jupyter Notebook（可选）
c.Spawner.default_url = "/lab"

c.JupyterHub.ip = "0.0.0.0"
c.JupyterHub.port = 8000

# 设置 Jupyterhub 的管理员账户
c.Authenticator.admin_users = {"yzh","hml"}
#如果未设置此配置值，则所有经过身份验证的用户都将被允许进入您的集线器。
c.Authenticator.allowed_users = {'yzh'}

上述过程完成后，即可启动 JupyterHub：

jupyterhub -f /etc/jupyterhub/jupyterhub_config.py

注意，会在启动 JupyterHub 的路径下生成 jupyterhub.sqlite 和 jupyterhub_cookie_secret 文件，如有必要可以进行定时备份。

切换 kernel

在 Jupyter 中，每个 kernel 对应一个运行环境。对于一个 conda 环境，只需要安装 ipykernel，即可被 Jupyter 识别到：

# 激活要使用的环境
conda activate jtest

# 安装 ipykernel
conda install ipykernel

# 添加到 Jupyter kernel list
## --name: conda 环境的名称
## --display-name: Jupyter 中显示的名称
python -m ipykernel install --user --name jtest --display-name "jtest"

重启当前用户的 Jupyter Server，即可在 kernel 菜单中发现 jtest。

其他用户登录 JupyterHub 时，无法看到该 kernel。

[!warning] 禁止使用（污染）JupyterHub 的默认 kernel！请自行创建 conda 环境以使用。

vaultwarden is an unofficial Bitwarden compatible server written in Rust, formerly known as bitwarden_rs.

拉取镜像

按理说部署 docker 需要先拉取镜像，不过这里使用 docker-compose 来启动，所以只需要准备好对应的 docker-compose.yml 文件然后启动即可，拉取镜像会自动执行。所以直接从配置项入手。

配置项

禁止新用户注册

默认情况下，任何能够访问后端的人都可以在此注册新账户，该功能可通过设置环境变量 SIGNUPS_ALLOWED 为 false 进行关闭：

docker run -d --name bitwarden \
  -e SIGNUPS_ALLOWED=false \
  -v /vw-data/:/data/ \
  -p 80:80 \
  vaultwarden/server:latest

需要注意的是, 现在注册和邀请功能仍然显示在页面上, 但是实际尝试注册和邀请会报错误消息。因为官方 Bitwarden server API 是一个开放平台, 所以无法完全禁用。

禁止组织邀请

即使 SIGNUPS_ALLOWED=false ，作为组织所有者或管理员的现有用户仍然可以邀请新用户。可以通过将 INVITATIONS_ALLOWED 环境变量设置为 false 来完全禁用此功能：

docker run -d --name bitwarden \
  -e SIGNUPS_ALLOWED=false \
  -e INVITATIONS_ALLOWED=false \
  -v /vw-data/:/data/ \
  -p 80:80 \
  vaultwarden/server:latest

无论如何限制，Vaultwarden 管理员都可以通过 admin page 邀请任何人。

限制注册邮箱域名

可以通过相应设置 SIGNUPS_DOMAINS_WHITELIST 将注册限制为来自某些域的电子邮件地址。例如：

• SIGNUPS_DOMAINS_WHITELIST=example.com (single domain)
• SIGNUPS_DOMAINS_WHITELIST=example.com,example.net,example.org (multiple domains)

[!warning] 如果设置了 SIGNUPS_DOMAINS_WHITELIST ，则会忽略 SIGNUPS_ALLOWED 的值。

开启邮箱验证

设置 SIGNUPS_VERIFY=true 可以让新注册用户成功登录之前进行电子邮件验证。这将防止有人使用具有正确域的虚假电子邮件地址进行注册。

admin page

启用

强烈建议在启用此功能之前激活 HTTPS，以避免可能的 MITM 攻击。

该页面允许服务器管理员查看所有注册用户并删除它们。即使注册被禁用，它也允许邀请新用户。

要启用管理页面，您需要使用 ADMIN_TOKEN 设置身份验证令牌并将其保密：

docker run -d --name vaultwarden \
  -e ADMIN_TOKEN=some_random_token_as_per_above_explanation \
  -v /vw-data/:/data/ \
  -p 80:80 \
  vaultwarden/server:latest

令牌可以是任何内容，但建议使用随机生成的长字符串，例如运行 openssl rand -base64 48 。

通过 /admin 可以进入 admin page。

首次在管理页面中保存设置时，将在 DATA_FOLDER 中生成 config.json 。该文件中的值将优先于相应的环境变量。但请注意，管理页面中的配置更改只有在您单击 Save 按钮后才会生效。

[!warning] 更改 ADMIN_TOKEN 后，当前登录的任何管理员仍然可以使用其现有的登录会话，直到过期。管理会话生命周期是可配置的，默认值为 20 分钟。

禁用

如果需要禁用 admin page，需要取消设置 ADMIN_TOKEN 并重新启动 Vaultwarden。

但如果环境变量 ADMIN_TOKEN 的值保留在上述 config.json 文件中，则删除该值不会禁用管理页面。要禁用管理页面，请确保未设置 ADMIN_TOKEN 环境变量，并且 config.json 中不存在 "admin_token" 键（如果该文件存在）。

保护令牌

按照 官方说明，有两种方式可以生成加密的 Argon2 PHC 字符串，这里我们用 vaultwarden 内置的 PHC 生成器对 ADMIN_TOKEN 进行 hash 加密：

docker exec -it 容器名称 /vaultwarden hash

Vaultwarden CLI 将要求输入密码两次，如果两次相同，它将输出生成的 PHC 字符串，如下：

ADMIN_TOKEN='$argon2id$****$****$****$****'

同样，对于生成的加密字符串，有三种方式可以进行配置：

1. 使用 docker-compose.yml，在 enviroment 中引入 ADMIN_TOKEN 即可：

   environment:
    ADMIN_TOKEN: $$argon2id$$****$$****$$****$$****
   

   注意，这里的 Argon2 PHC 跟生成的略有不同，不仅没有引号包裹，且原本的每个 $ 必须用两个连续的 $$ 进行转义。

2. 直接在 CLI 中通过 -e ADMIN_TOKEN 参数引入。
3. 通过 .env 文件：

    # 在.env文件中如下配置
    VAULTWARDEN_ADMIN_TOKEN='$argon2id$v=19$m=65540,t=3,p=4$MmeK.....'
   
    # 然后在docker-compose.yml中引入
    environment:
      - ADMIN_TOKEN=${VAULTWARDEN_ADMIN_TOKEN}
   

4. 也可以在 /admin 界面中进行修改，不过官方似乎不建议这么干。

如果加密字符串不合法，会给出警告：

WARNING: The argon2id variable is not set. Defaulting to a blank string.
WARNING: The v variable is not set. Defaulting to a blank string.
WARNING: The m variable is not set. Defaulting to a blank string.
...

禁用令牌

将 DISABLE_ADMIN_TOKEN 变量设置为 true 可以禁用用于身份验证的内置 ADMIN_TOKEN ，同时启用管理面板。任何有权访问该 URL 的人都可以访问管理面板。您将需要采取额外的步骤来保护它。这包括外部和本地。

代理设置

官方给出了一些用户的代理 案例，包括 caddy，nginx 等，这里笔者习惯于 nginx，下面给出自用的配置。

# vaultwarden proxy config
# The `upstream` directives ensure that you have a http/1.1 connection
# This enables the keepalive option and better performance
#
# Define the server IP and ports here.
upstream vaultwarden-default {
  zone vaultwarden-default 64k;
  server 127.0.0.1:9988;
  keepalive 2;
}

# Needed to support websocket connections
# See: https://nginx.org/en/docs/http/websocket.html
# Instead of "close" as stated in the above link we send an empty value.
# Else all keepalive connections will not work.
map $http_upgrade $connection_upgrade {
    default upgrade;
    ''      "";
}

# Redirect HTTP to HTTPS
server {
    listen 80;
    server_name your_vaultwarden.com;

    if ($host = your_vaultwarden.com) {
        return 301 https://$host$request_uri;
    }
    return 404;
}

server {
    # For older versions of nginx appened http2 to the listen line after ssl and remove `http2 on`
    listen 443 ssl;
    # http2 on;
    server_name your_vaultwarden.com;

    # Specify SSL Config when needed
    ssl_certificate /path/to/your/fullchain.cer;
    ssl_certificate_key /path/to/your/domain.key;
    client_max_body_size 525M;

    location / {
      proxy_http_version 1.1;
      proxy_set_header Upgrade $http_upgrade;
      proxy_set_header Connection $connection_upgrade;

      proxy_set_header Host $host;
      proxy_set_header X-Real-IP $remote_addr;
      proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
      proxy_set_header X-Forwarded-Proto $scheme;

      proxy_pass http://127.0.0.1:9988;
    }
}

部署容器

这里给出一个自用的 docker-compose.yml：

version: '3'

services:
  vaultwarden:
    image: vaultwarden/server:latest
    container_name: vaultwarden
    restart: unless-stopped
    volumes:
      - /deploy/vaultwarden/data:/data
    ports:
      - 9988:80
    environment:
      DOMAIN: "https://your_vaultwarden.com"
      LOG_FILE: "/data/access.log"
      SIGNUPS_ALLOWED: true
      INVITATIONS_ALLOWED: false
      ADMIN_TOKEN: $$...$$...$$....$$...$$...

拉取镜像并启动容器：

# 进入项目根目录
cd /deploy/vaultwarden

# 创建并启动容器
docker-compose up -d

自动备份

使用脚本对 vaultwarden 数据打包，然后借助阿里云对象存储 CLI 工具 ossutil 上传至对象存储 bucket，将该过程设置定时任务以完成自动备份。

备份脚本 oss-upload.sh 如下：

#!/bin/bash

# 检查是否传入路径参数
if [ $# -eq 0 ]; then
    echo "Error: Please provide a directory path as an argument."
    exit 1
fi

path=$1
echo "target is $path"

# 检查传入的路径是否存在
if [ ! -d $path ]; then
    echo "Error: The specified directory does not exist."
    exit 1
fi

timestamp=$(date +"%Y-%m-%d")

# 创建压缩文件
tar -zcPf "${timestamp}.tar.gz" $path >> output.txt

# 上传压缩文件到oss
ossutil cp -f "${timestamp}.tar.gz" oss://vault-warden/ >> output.txt

# 删除压缩文件
rm "${timestamp}.tar.gz"

echo "Script executed at $(date)" >> output.txt

执行完成后，可手动执行进行测试：

chmod +x oss-upload.sh
./oss-upload.sh /path/to/vault-warden

脚本执行后， output.txt 中存有过程日志记录，bucket 中会出现 YYYY-MM-DD.tar.gz 文件。由于这里是每天备份一次，所以名称精确到天即可，如有进一步需求可自行修改。

设置定时任务方式如下：

crontab -e

在文件中添加一行：

0 0 * * * /path/to/oss-upload.sh /path/to/vault-warden

保存并退出即可。

 ssh-keygen -t ed25519 -C "sun2ot@qq.com" -f ~/.ssh/your-key

• -t：加密方式，rsa，ed25519，或者别的 GitHub 支持的都可以。
• -C：GitHub 邮箱，用于注释密钥。
• -f：指定生成密钥的位置和名称。建议存放在 ~/.ssh/ 下，但名称可以自定义以避免重复。无需指定密钥文件的后缀，openssh 会自动生成。

生成密钥时会提示是否需要设置 passphrase，这个可以置空，不影响使用。

生成完成后，会在 ~/.ssh/ 下生成 your-key（私钥）和 your-key.pub（公钥）。接下来，需要将公钥上传到 GitHub。

添加公钥到 GitHub

官方教程：英文 中文

1. 点击右上角 GitHub 头像
2. 点击 Settings
3. 左侧菜单列表找到 SSH and GPG keys
4. 点击绿色的 New SSH key
   1. Title 是用以区分的密钥别名，随意指定即可
   2. Key Type 保持 Authentication Key 不变
   3. Key 中填入刚刚生成的 your-key.pub 中的内容，例如 ssh-ed25519 123456abcd your@email.com
   4. 点击 Add SSH key 即可

通过 SSH 进行克隆

首先测试与 GitHub 的 SSH 连通性：

ssh -T git@github.com

如果一切正常应该会输出如下内容：

Hi your-github-name! You've successfully authenticated, but GitHub does not provide shell access.

可能还有一些 Warning，或者提示写入 fingerprint 的提示，这都是正常的。

但如果报错 kex_exchange_identification: read: Connection reset by peer，请检查网络环境。大概率是🧱的问题，需要🪜来代理一下，见 git 代理。

如果生成密钥时指定了自定义名称，建议在 ssh 配置文件中写明，防止出现 Permission denied (publickey). 错误：

vim ~/.ssh/config

# 在其中添加
Host github.com
  Hostname ssh.github.com
  IdentityFile /path/to/your/private-key  # 自定义密钥路径
  User git

处理完上述问题后，便可以正常访问仓库：

git clone git@github.com:<github-name>/<repo-name>.git

这个克隆地址与 HTTP 类似，都可以在 GitHub 的网页复制下来。

proxies:
  - {name: node, server: 192.168.1.1, port: 8388, type: ss, cipher: chacha20-ietf-poly1305, password: 123456, udp: true}

我们通常看到的 ss 订阅链接如下：

ss://Y2hhY2hhMjAtaWV0Zi1wb2x5MTMwNToxMjM0NTZAMTkyLjE2OC4xLjE6ODM4OA

这其实是一个经过 urlsafe_base64 加密后得到的字符串：

Encode bytes using the URL- and filesystem-safe Base64 alphabet.

Argument s is a bytes-like object to encode. The result is returned as a bytes object. The alphabet uses '-' instead of '+' and '_' instead of '/'.

换言之，只要先对 ss 链接进行 base64 解码，即可得到相关参数：

注意：只解码 ss:// 后面的内容

chacha20-ietf-poly1305:123456@192.168.1.1:8388

这也就是上文我们给出的 Clash 节点配置信息。而 ss 链接在没有进行 base64 加密前的格式，正是：

ss://method:password@server:port  

显然，这存在一个问题：name 和 udp 参数不在其中。换言之，如果你将自己的 Shadowsocks 节点配置按照如上方式加密，得到的 ss 订阅链接是无法解析出 name 和 udp 参数的。

通过联合 subconverter 进行研究，我发现一个适用于 Clash 的 ss 订阅链接格式如下：

ss://url_base64(method:password@server:port?udp=1)#name

• url_base64 只加密 ss:// 与 #name 之间的内容
• 带有 ?udp=1 则会解析出 udp=true；反之则不会
• #name 直接添加在加密完成后的完整 ss 链接后

当然，@server:port 部分也可以不加密：

ss://Y2hhY2hhMjAtaWV0Zi1wb2x5MTMwNTpwYXNzd29yZA@www.example.com:1080#name

Tmux 是什么？

命令行的典型使用方式是，打开一个终端窗口（terminal window，以下简称 " 窗口 "），在里面输入命令。用户与计算机的这种临时的交互，称为一次 " 会话 "（session） 。

会话的一个重要特点是，窗口与其中启动的进程是连在一起的：

• 打开窗口，会话开始；
• 关闭窗口，会话结束，会话内部的进程也会随之终止，不管有没有运行完。

一个典型的例子就是，SSH 登录远程计算机，打开一个远程窗口执行命令。这时，网络突然断线，再次登录的时候，是找不回上一次执行的命令的。因为上一次 SSH 会话已经终止了，里面的进程也随之消失了。

为了解决这个问题，会话与窗口可以 " 解绑 "：窗口关闭时，会话并不终止，而是继续运行，等到以后需要的时候，再让会话 " 绑定 " 其他窗口。

Tmux 就是会话与窗口的 " 解绑 " 工具，将它们彻底分离。

Tmux 的标准定义是：

一个在 Unix 和类 Unix 系统上运行的终端复用器（terminal multiplexer）。它允许用户在单个终端窗口中同时访问多个终端会话。使用 Tmux，您可以创建、管理和控制多个终端会话，这些会话可以在后台运行，即使您断开了与服务器的连接也可以保持运行。这使得在服务器上同时运行多个终端会话变得更加高效和方便。

Tmux 基本组件概念

Tmux 的核心组件分为三个：

• 会话 session
• 窗口 window
• 窗格 pane

下图是一个布局示意图

通常来说，一个用户只需要创建一个 session 即可。不同的任务可以在不同的 window 下完成。每个 window 可以按需要划分为若干个 pane 来辅助完成任务。

部署 Tmux

最简单的当然是 apt install tmux，不过这样安装的版本并不是最新版（但是完全不影响使用）。我个人喜欢手动编译，反正要不了多久。

首先准备编译环境：

sudo apt update
sudo apt install libevent-dev ncurses-dev build-essential bison pkg-config automake

Tmux wiki 中没有提到 automake，但不排除有的机器，例如容器环境，没有该工具，所以多装一个保险。

然后编译构建：

git clone https://github.com/tmux/tmux.git
cd tmux
sh autogen.sh
./configure && make

这里是 git clone 的源码，而不是 release 发布的 tmux-xx.tar.gz，否则找不到 autogen.sh

如何使用 Tmux

关于快捷键

Tmux 有大量的快捷键。所有快捷键都要通过前缀键唤起。默认的前缀键是 Ctrl + b，即先按下 Ctrl + b，快捷键才会生效。

举例来说，帮助命令的快捷键是 Ctrl + b + ?。它的用法是，在 Tmux 窗口中，先按下 Ctrl+b，再按下 ?，就会显示帮助信息。

然后，按下 ESC 键或 q 键，就可以退出帮助。

由于快捷键的数量太多，全部记住未必就真的“快捷”，个人认为部分指令的缩写也足够简洁明了（除非英语不太行），所以下文只会提到常用的快捷键。

一些 Reference：

• https://gist.github.com/ryerh/14b7c24dfd623ef8edc7

会话

创建会话

# 创建一个名为 wym 会话
tmux new -s wym

执行后，会自动进入 wym session，并在终端下方进行亮绿色显示 [wym]。

在这个 session 中执行的命令，产生的任何输出都不会随着 ssh 连接的断开而丢失，即直接关闭终端程序或者网络突然断开，都不会影响当前的会话。

连接会话

当我们登录服务器并需要重新连接到之前的会话时，可以通过如下方式：

# 查看当前正在运行的会话
tmux ls
# -----输出如下-----
wym: 1 windows (created Mon Apr  1 12:29:03 2024)
yzh: 1 windows (created Fri Mar 29 09:52:33 2024)

可以看见，当前有两个 tmux 会话，一个叫 wym，一个叫 yzh。我们需要重新连接到 wym 以继续之前的工作，执行：

# tmux attach (附上) -t (target, 目标) session_name
tmux attach -t wym

# 也可以将 attach 简写为 at
tmux at -t wym

• 如果退出会话前，有进程正在输出，则你会看到输出仍在进行或者已停止
• 之前执行的指令记录仍然存在

退出会话

其实“退出”叫做“分离/卸载”更合适，因为关键字是 detach

退出会话有两种方式：快捷键和指令

# 指令
tmux detach

# 快捷键
ctrl + b + d

综上，一般的工作流程是：创建会话摸摸鱼，然后退出会话恰个饭，接着连接会话继续摸。。。

杀死会话

除非你确定这个 session 已经没用了，否则不要轻易这么做。

tmux kill-session -t <session-name>

窗口

多个不同的任务，可以分别在不同的窗口内执行。例如 Window1 用来跑模型，Window2 用来看日志。

创建窗口

输入 tmux new 后按 Tab，就可以得到相应的提示信息。

# 指令(可以指定窗口的名称)
tmux new-windows -n <window-name>

# 快捷键
ctrl + b + c  # c = create

快捷键创建的窗口会使用当前的 shell 作为名称，例如 bash，zsh 等，无法自定义名称。

切换窗口

# 查看当前开启的窗口
tmux lsw  # lsw = list window
# -----输出如下-----
0: zsh (1 panes) [120x29] [layout cafd,120x29,0,0,0] @0
1: 2- (1 panes) [120x29] [layout cb00,120x29,0,0,3] @3
2: zsh* (1 panes) [120x29] [layout cb02,120x29,0,0,5] @4 (active)

可以看见终端下方的高亮提示条内，其实是有相关辅助信息的，例如：

[wym]   0:zsh   1:zsh-   2:zsh*

其中，[wym] 是当前的 session 名称，0,1,2 是三个 window 的编号。* 表示当前所处的时候 2 号 window，这和 tmux lsw 输出中的 active 所在行是对应的。- 表示上一个 window。

如果要切换窗口，也有两种方式：

# 指令：切换到0
tmux select-window -t <target-window>  # tmux select-window -t 0

# 快捷键
ctrl + b + n  # n = next，下一个窗口
ctrl + b + p  # p = previous，上一个窗口
ctrl + b + w # w = window，可以在列表中选择要切换的窗口（推荐）

杀死窗口

杀死的命令其实都差不多的，可以 tmux kill 然后按 Tab 提示。

# 指令
tmux kill-window -t <target-window>

# 快捷键
ctrl + b + &  # 杀死当前窗口，会问你 yes or no

窗格

创建窗格

窗格其实就是把一个窗口（window）分割为多个小块，每个块就是一个 pane。

屏幕够大的话，非常 nice👍

那么怎么分割呢？很显然，水平方向可以分成左右两块，垂直方向可以分成上下两块。如果要分多块，就是在每个 pane 里继续上下左右分割，行成不规则形状。

# 水平分割
tmux split-window -h  # h = horizontally

# 垂直分割
tmux split-window -v  # v = vertically

例如先后执行上面两句指令的话，你会得到这样一个布局：

切换窗格

显然，屏幕上有这么多块，需要来回切换。这里有若干种方式：

1. 参见文末的开启鼠标控制一节。开启后，就可以进行符合直觉的鼠标点击切换了。
2. 指令
3. 快捷键

下面针对 2,3 两点进行介绍。

指令切换

# 查看当前 pane
tmux lsp  # lsp = list pane

# 类似于上面的 select-window, pane 也可以 select
tmux select-pane -t <target-pane>

快捷键

ctrl + b + %  垂直分割
ctrl + b +  "  水平分割
ctrl + b + q 显示每个窗格是第几个，当数字出现的时候按数字几就选中第几个窗格

杀死窗格

# 指令
tmux kill-pane -t <target-pane>

# 快捷键
ctrl + b + x  关闭窗格

配置 Tmux

开启鼠标控制

# 创建Tmux配置文件
vim ~/.tmux.conf

# 添加以下内容开启鼠标控制
set -g mouse on

# 重载Tmux配置
tmux source-file ~/.tmux.conf

即时生效，无需重启 Tmux

中文显示异常

当 Tmux 的中文显示异常时（例如全部变为了下划线 _），可以尝试如下方式：

vim ~/.bashrc # 或者 vim ~/.zshrc
# 添加如下内容
export LANG=en_US.UTF-8 
# 生效环境变量
source ~/.bashrc # 或者 source ~/.zshrc

这个选项 .zshrc 默认就有，只不过被注释掉了

也可以采用 -u 参数强制 Tmux 使用 utf8：

# 使用 tmux 时添加 -u 参数
tmux -u new -s xxx

或者干脆使用 alias：

alias tmux='tmux -u'

1. MATLAB 是收费软件，且学校没有购买授权，因此只能安装破解版。
2. 本教程全过程需 root 权限，但完成后普通用户可以使用。

下载 MATLAB 镜像及破解补丁

这里提供 R2019b 和 R2020a 两个版本。其中前者为服务器已经部署的版本，后者为网络资源，可用性未知，仅作参考。

# R2019b
链接：https://pan.baidu.com/s/1AZ_LmyzfTUJ4nGzOBaTghg 
提取码：7pso 
--来自百度网盘超级会员V6的分享

# R2020a
链接：https://pan.baidu.com/s/1LHSmd7nC8x6QmziyYt6whQ 
提取码：cmmd 
--来自百度网盘超级会员V6的分享

由于属于盗版资源，因此无直链可以提供。但可以通过 Alist 中转请求的方式满速下载到服务器（前提是你有百度网盘的会员）。

curl -L -X GET "https://xxx/d/xxx/R2019b_Linux.iso" -H "User-Agent: pan.baidu.com" -o R2019b_Linux.iso

之所以不先下载再上传，是因为司马校园网。希望后来者的实验条件不要如此艰苦。。。

安装 MATLAB

# 创建临时挂载路径
mkdir /mnt/matlab

# 挂载 iso 镜像
## -o loop: 将文件视为块设备。这样可以让你像挂载硬盘分区一样挂载一个文件。
mount -o loop R2019b_Linux.iso /mnt/matlab

# 退出挂载路径后再安装
cd ~
# 执行指令静默安装
## 注意替换参数：
## - destinationFolder: 安装路径
## - activationPropertiesFile: 破解补丁路径
/mnt/matlab/install -mode silent -fileInstallationKey 09806-07443-53955-64350-21751-41297 -agreeToLicense yes -activationPropertiesFile Matlab-R2019b-Linux64-Crack/license_standalone.lic -destinationFolder /opt/matlab2019b/

# 也可以直接 /mnt/matlab/install，不过需要打开 X11 显示，然后对照着上面的信息在 GUI 中填进去。听不懂的话就略过这一段吧。

# 等待安装...很久...大概10min?

输出如下结果即安装完成：

(三月 25, 2024 19:00:27) Exiting with status 0
(三月 25, 2024 19:00:29) End - Successful.
Finished

注入破解补丁

注意，是破解补丁包里的文件往安装路径下复制。

# 解压破解补丁包
tar -zxvf Matlab-R2019b-Linux64-Crack.tar.gz

# 注入启动组件破解补丁
cp Matlab-R2019b-Linux64-Crack/R2019b/bin/glnxa64/* /opt/matlab2019b/bin/glnxa64/ -r

# 注入破解许可证
cp Matlab-R2019b-Linux64-Crack/license_standalone.lic /opt/matlab2019b/licenses

至此，root 用户应该可以执行 /opt/matlab2019b/bin/matlab 启动MATLAB(需开启 X11)。但普通用户尚且无法启动，仍会提示需要激活，原因是相关破解补丁权限为 root，普通用户无法读取，因此需要修改相关权限。

# 新增 matlab 用户组
groupadd matlab
# 将需要使用 matlab 的用户添加进组
usermod -aG matlab u_23_1,yzh
# 修改 matlab 文件的所属组为 matlab
chown root:matlab ./matlab2019b/ -R
# 修改 matlab 文件的权限为 775
chmod 775 matlab2019b/ -R

至此，普通用户可通过 /opt/matlab2019b/bin/matlab 顺利启动 MATLAB。如需配置环境变量，在 .bashrc 或 .zshrc 中添加export PATH=/opt/matlab2019b/bin:$PATH 即可。

点击右上角头像，菜单中进入 Settings

点击 Create New Token 生成新的 Token，浏览器会自动下载鉴权文件：

注意这句话：Ensure kaggle.json is in the location ~/.kaggle/kaggle.json to use the API.，意思是需要将下载的 kaggle.json 放到 Linux 服务器的 ~/.kaggle/ 下。

cd ~
mv -r kaggle.json ~/.kaggle/

下载数据集

首先下载 kaggle 指令：

pip install kaggle

在 kaggle 上找到要下载的数据集首页，然后点击右上角菜单，复制 API 指令：

复制的指令如下：

kaggle datasets download -d yelp-dataset/yelp-dataset

下载指定版本数据集

下拉 kaggle 数据集页面，在页面的右侧会看到 Data Explorer。默认情况下下载的是最新版数据集。

以图中的 yelp 数据集为例，我并不需要最新的 yelp 数据集，而是 yelp2018。因此点击图中的 Version 4，在弹出窗口中选择想要的版本即可。

但比较蛋疼的是，经过本人的不屑研究，没有找到通过 kaggle api 下载历史版本数据集的方法（我指的是 kaggle CLI）。因此迫不得已，只能使用邪术了。

1. 在服务器部署 aria2
2. F12 大法进入浏览器开发者页面，然后点击下载，从 网络 选项卡找到下载链接并复制（如果有 idm 等插件直接嗅探就行了）
3. 用服务器通过 aria2 下载

1. 以下排名不分先后，脑子想到哪写到哪
2. 背景不是大资本 = 没钱 + 限制多 + 不好用，故不予收录

国内

文心一言

• 级别：臭🐟烂🦐
• 背景：百度
• 地址： https://yiyan.baidu.com/
• 简评：v3.0 难用的一比，v4.0 收费贼贵，还不能免费试用，宏颜获水。

通义千问

• 级别：🌟能用
• 背景：阿里
• 地址： https://tongyi.aliyun.com/
• 简评：毕竟是码农心里的白月光，对话一般，写代码还凑活。
• 相关产品：
  • 通义听悟：语音转文字 yyds
  • 通义灵码：支持 vscode 插件，类似 copilot，不用我多说了吧

智谱清言

• 级别：🎁好用
• 背景：清华
• 地址： https://chatglm.cn/
• 简评：4.0 免费使用，而且支持检索互联网内容，堪称低配版 gpt4.0 + copilot
• 备注：善用智能体有奇效。这个智能体不就是 prompt 市场吗，不过能铺开确实很舒服，不用自己编写 prompt 了。

腾讯混元

• 级别：臭🐟烂🦐
• 背景：腾讯
• 地址： https://hunyuan.tencent.com/
• 简评：是个小程序，这一点就够判它死刑了。更何况腾讯自己内部都觉得不好用，也好意思推出来？

讯飞星火

• 级别：❓
• 背景：科大讯飞
• 地址： https://xinghuo.xfyun.cn/
• 简评：按理说讯飞输入法这么大的招牌，大模型语料数据应该不缺的。不过没有深度使用过，故级别未知。

豆包

• 级别：❓
• 背景：字节跳动
• 地址： https://www.doubao.com/chat/
• 简评：可惜了，我不刷抖音，这玩意降智。

Kimi

• 级别：❓
• 背景：中信建投
• 地址： https://kimi.moonshot.cn/
• 简评：Tg 上看到的，据称是国产大模型的神。主要是长文本相当牛逼（200W）。而且背景是中信建投。。。

天工

• 级别：❓
• 背景：昆仑万维（什么领域都想横插一脚的投资公司）
• 地址： https://work.tiangong.cn/
• 简评：大模型一吹，股价翻倍。

国外

请在富强的网络条件下使用。

ChatGPT

• 级别：🎁好用
• 背景：OpenAI
• 地址： https://chat.openai.com/
• 简评：鼻祖。不过只要一用反问语气模型就立马变卦，对中文有点不太友好，建议英文对话。

Gemini

• 级别：❓
• 背景：Google
• 地址： https://gemini.google.com/
• 简评：不支持香港节点，对分流策略有点要求。

OpenAI Api 站点

强烈推荐自建前端 + Api 的方式使用。

• https://api.aigcbest.top/
• https://home.nextapi.fun/

校园网给出的三个 DNS，经反查后对应信息为

202.201.112.1    dns.nmu.edu.cn
202.100.96.68  宁夏银川市 电信DNS服务器
221.199.12.157   宁夏银川市 大博金网吧(胜利南街永春巷27号)

校园网服务商为电信，连接校园网需要校内验证，综上前两个 DNS 问题不大。第二个视情况可以挑选一个西夏区的电信 DNS。不过第三个就有点抽象了。。。

Against NUN

2024年03月18日 18:58:53，经运维人员证实，校园网锁死 10Mbps，特此启动Against NUN计划。

双网卡策略

ssh 连接问题

如果去搜索指定网卡进行 ssh 连接，大概率会从 CSDN 上看到一个互相抄来抄去的解决方案：通过 ssh -B/-b 绑定建立连接的 IP/网卡。但是情况是 Windows 并不支持这种方式。

ssh -B -h
usage: ssh [-46AaCfGgKkMNnqsTtVvXxYy] [-B bind_interface]
           [-b bind_address] [-c cipher_spec] [-D [bind_address:]port]
           [-E log_file] [-e escape_char] [-F configfile] [-I pkcs11]
           [-i identity_file] [-J [user@]host[:port]] [-L address]
           [-l login_name] [-m mac_spec] [-O ctl_cmd] [-o option] [-p port]
           [-Q query_option] [-R address] [-S ctl_path] [-W host:port]
           [-w local_tun[:remote_tun]] destination [command]

BindInterface not supported on this platform.

所以只能通过修改路由表解决。首先找到连接校园网的网卡的 IP 地址：

ipconfig /all

# 以下内容省略了不重要的部分

无线局域网适配器 WLAN 2:
   连接特定的 DNS 后缀 . . . . . . . :
   描述. . . . . . . . . . . . . . . : MERCURY Wireless N Adapter
   物理地址. . . . . . . . . . . . . : D4-84-09-5C-ED-6F
   IPv4 地址 . . . . . . . . . . . . : 172.26.15.89(首选)

接着，在管理员模式下，添加路由表记录：

route add 172.16.16.242 mask 255.255.255.255 172.26.15.89

这会将前往 172.16.16.242 的请求路由到 172.26.15.89，也就是校园网给网卡 2 分配的 IP 地址。

当然，可能你会发现路由表中，新增的这条记录跃点数较低：

route print


IPv4 路由表
===========================================================================
活动路由:
网络目标        网络掩码          网关       接口   跃点数
0.0.0.0          0.0.0.0    192.168.15.58   192.168.15.141     30
0.0.0.0          0.0.0.0   172.26.255.254     172.26.15.89     55
127.0.0.0        255.0.0.0            在链路上         127.0.0.1    331
127.0.0.1         255.255.255.255            在链路上         127.0.0.1    331
127.255.255.255  255.255.255.255            在链路上         127.0.0.1    331
172.16.16.242       255.255.255.255            在链路上      172.26.15.89     56

但路由选择的过程是这样的：

1. 路由器查找路由表，寻找与目标 IP 地址最匹配的条目（与掩码进行与运算）。
2. 如果找到精确匹配（如 /32 或 255.255.255.255），则直接发送到那个地址，因为目标就在本地网络上。
3. 如果没有精确匹配，路由器会查找具有最长网络前缀匹配的条目（即最具体的网络掩码）。
4. 如果没有找到具体的匹配项，路由器会使用默认路由（0.0.0.0/0）来路由数据包，并且在这种情况下，会选择跃点数最低的默认路由。

删除路由：

route delete 172.16.16.242 mask 255.255.255.255

添加或修改路由（如果需要指定新的下一跳地址）：

route add 172.16.16.242 mask 255.255.255.255 172.26.15.90

内网访问

网络目标        网络掩码          网关       接口   跃点数
0.0.0.0          0.0.0.0    192.168.15.58   192.168.15.141     30
0.0.0.0          0.0.0.0   172.26.255.254     172.26.15.89     55

根据路由表能看出，校园网路由的跃点为 55，大于手机热点的跃点。即使断开热点再连上，也不过是两个路由记录的顺序调换一下，跃点数仍然一大一小。这导致热点的默认网关优先级更高，导致内网无法访问。

不过在翻了翻 虚空终端 Docs 之后，找到了出站接口的设置参数。因此，只需要在 mihomo 的配置文件指定流量出口的网卡即可解决。

interface-name: WLAN

这里的网卡名称通过 ipconfig /all 可以查到，“无线局域网适配器”后面的内容就是网卡名称：

ipconfig /all

无线局域网适配器 WLAN
......

当然，直接通过控制面板或者 powershell 去修改对应网络的跃点数也行，不过这样更麻烦不是吗。

WPS 个人版启用 VBA 环境

[!bug] 正常情况下企业版内置，个人版需要购买授权才能用。

虽然 WPS 提示要安装 VBA，但实测安装了 VBA7.1 后不起作用，后来看了下网上说的不是 VBA，而是 WPS VBA 插件。然后就去下了一个试试：

链接： https://pan.baidu.com/s/16GKbt95d9iCAviKMj2OcOg 提取码：e27x

果不其然，并不是 VBA 的 msi 程序，而是一个 exe，运行后出现的是 kingsoft 界面，看来是给 WPS 软件打的补丁。

安装完成后，即可正常使用 zotero 等软件。

WPS 中启用 MathType

[!warning] 适用于较新的 WPS 12.0+ 以及 MathType 7.0+，其他版本未做测试！

与 Zotero 不同，MathType 这玩意即使安装完成也不会自动配置 WPS，具体体现在两个问题：

1. WPS 启动后没有 MathType 选项卡（缺少了相应的 dotm）
2. 加载 dotm 以显示选项卡后，插入公式会报错找不到 MathPage.wll

下面分别介绍如何解决。

让 WPS 显示 MathType 选项卡

对于 dotm 文件的问题，不要试图在工具-加载项这里添加。在这里添加虽然可以正常显示选项卡，但不会随着 WPS 自启动。所以你需要做的是：

1. 找到 MathType 的安装路径

   什么？你不知道怎么找？右键 MathType 的快捷方式，点击 打开文件所在位置。你要是连快捷方式也不知道怎么找的话，建议 remake

2. 进入 \Office Support\32 这个路径，这里面存放着适用于 32 位 office 的 dotm 模板文件

   至于为什么是 32 位，那得问问金山为什么 2024 年还在生产 32 位的电子垃圾了。别扯什么兼容性，提供 32/64 两种安装包就能解决的问题。

3. 找到 MathType Commands 2016.dotm 这个文件，复制粘贴到 *\WPS Office\12.1.0.16412\office6\startup 路径下。

   这个路径是你 WPS 的安装路径，切记粘贴到版本号最新的那个路径下，因为我们的 WPS 居然把占用庞大的历史版本软件也保存在了用户机上，真是国产之光呢^_^

至此，重启 WPS，应该就可以看到 MathType 的选项卡了，不过应该是无法使用的。

WPS 中使用 MathType 报错找不到 mathpage.wll 文件

解决步骤如下：

1. 找到 MathType 安装路径，进入 \MathPage\32
2. 里面只有一个 MathPage.wll，依然复制粘贴到 *\WPS Office\12.1.0.16412\office6\startup 路径下

[!warning] dotm 文件和 MathPage.wll 文件需要一一对应，要么全是 32 位，要么全是 64 位！

WPS 启用 Zotero

正常情况下，WPS 会自动加载属于 Office Word 的 Zotero.dotm，即 C:\Users\y2pub\AppData\Roaming\Microsoft\Word\Startup\Zotero.dotm。但此时可能由于软件升级或别的什么原因，导致 WPS 出现异常，即可见选项卡但无法使用 Zotero。

因此，找到 Zotero安装路径/extensions，打开文件夹，里面有一个 Zotero.dotm

如果是 Zotero7 的测试版，该文件在 Zotero安装路径/integ ration/word-for-windows/ 下。

将其复制到 C:\Users\y2pub\AppData\Roaming\Microsoft\Word\Startup\。然后重启 WPS 即可。

当然，你也可以选择给两个软件分别配置 Zotero.dotm，注意事项，见上文让 WPS 显示 MathType 选项卡。

关于 Office Word

1. 开启 MathType 选项卡的方式与 WPS 类似，只是路径不同，为：C:\Program Files (x86)\Microsoft Office\root\Office16\STARTUP
2. 报错 mathpage.wll 时，相关路径为：C:\Program Files (x86)\Microsoft Office\root\Office16

有的是 x86 路径，有的是 x64 路径，都看看

注意，office 365 似乎无需手动配置，默认启动。

在 2023 年的微软开发者大会上，推出了 Dev Drive 新存储卷。从今天开始，Dev Drive 将面向所有使用最新 Windows 11 的 Windows 开发者开放。

对于这个巨硬推出的新玩具，网上相关资料较少，因此这里做一个记录。

About Dev Drive on Windows 11 by Microsoft Official

受信与反病毒策略

管理员模式运行 powershell：

# 将开发驱动器指定为受信任的驱动器
fsutil devdrv trust <drive-letter>:

# 查询开发驱动器是否受信任
fsutil devdrv query <drive-letter>:

不能将计算机上的 C: 驱动器指定为开发驱动器。开发人员工具（如 Visual Studio、MSBuild、.NET SDK、Windows SDK）应存储在 C:/ 驱动器上，而不是存储在开发驱动器中！

默认情况下，筛选器管理器 将关闭开发驱动器上的所有筛选器，防病毒筛选器除外。当然，我们也可以关闭。

如果你的电脑上运行了 Windows Defender 或者 360 之类的安全软件，执行 fsutil devdrv query 大概率会看到有相关字样。由于个人小鸡基本不存在病毒攻击的问题，因此这里我们可以将防病毒策略完全关闭以提高开发驱动器的性能：

fsutil devdrv enable /disallowAv

然后检查效果：

# 再次查询
fsutil devdrv query <drive-letter>:

# 结果如下
This isNo filters are currently attached to this developer volume.

自动挂载

由于新电脑有两个硬盘位，所以在从盘位划分了一块作为 Dev driver。但奇怪的是，虽然正常使用，但开机、重启时无法自动挂载，必须手动找到 VHDX 文件进行挂载。暂不清楚是什么原因导致的，但总之，在微软 devhome 项目的 issue #1903 找到了解决方案。

简单来说就是新建一个计划任务，然后用 diskpart.exe 执行一段磁盘挂载的脚本即可。

需要对位于 D:\ 下的 obsidian 文件夹中的所有文件进行定时全量备份。

操作步骤

快捷键按 Win+R 打开运行输入 taskschd.msc 打开 “任务计划程序”，创建一个基本任务。

名称可以自己任意填，描述可不填。

点击下一页，任务触发器选择每天

设置每天自动备份的具体时间，设置完成后点击 “下一步” 按钮。

选择要启动的程序，填入相应参数，然后点击 “下一步” 按钮。这里我设置的任务是调用 powershell 执行对应脚本，实现将路径下文件打成压缩包后移动到另一个盘实现备份效果。

注意这里的程序路径如果有空格，切记加引号。或者点击 浏览 一步一步选中目标程序即可。

填好后点击 “下一步”，然后点击完成按钮，保存任务计划。

点击 更改用户或组

注意，如果前面的设置有误，或者想要修改，这里是可以更改的（上方的菜单栏）

在条件中，取消勾选电源选项

在设置中，勾选如上选项

设置完成后，右键任务尝试运行

原因

通过 git push 提交时可能会碰到如下错误。字面意思很清楚，密码验证的方法已经在 2021 年 8 月 13 号后就失效了，因此我们需要改用 token 鉴权。

git push

# 输出
Username for 'https://github.com': sun2ot
Password for 'https://sun2ot@github.com':
remote: Support for password authentication was removed on August 13, 2021.
remote: Please see https://docs.github.com/en/get-started/getting-started-with-git/about-remote-repositories#cloning-with-https-urls for information on currently recommended modes of authentication.
fatal: Authentication failed for 'https://github.com/sun2ot/xxx.git/'

解决方案

方式一：使用 token

github 头像下拉菜单——settings——新页面左侧导航栏最后一项 developer settings

personal access token——Tokens (classic)

经典模式的 token 可以设置永不过期，用起来比较方便，当然，被盗了就很不安全，所以自行取舍。

生成的 token 作用范围勾选 repo 就足够了，你也可以全勾上，当做万能 token。

然后进入项目根目录

git remote set-url origin https://<your token>@github.com/<your name>/<repo>.git

以后就可以直接 git push 了。

方式二：使用 ssh

使用该方法的前提是已经配置了 GitHub ssh 密钥！

# 查看远程地址别名及路径
git remote -v

origin  https://github.com/kkeeliu/doubao_community_frontend.git (fetch)
origin  https://github.com/kkeeliu/doubao_community_frontend.git (push)

# 修改远程地址
git remote set-url origin git@github.com:<your name>/<repo>.git

# 查看修改是否成功
git remote -v

# 设置
git config --global http.proxy "socks5://127.0.0.1:7890"  # clash的socks5端口是7890
git config --global https.proxy "socks5://127.0.0.1:7890" # 根据实际情况做修改

# 恢复
git config --global --unset http.proxy
git config --global --unset https.proxy

git 的配置范围有三种，一般情况下可以选择不加 --global 参数，实现局部（也就是当前仓库）配置，毕竟不是每一个库都需要代理吧。

# 查看当前git config
# 系统
git config --system --list
# 全局
git config --global --list
# 当前仓库
git config --local --list

如果是在克隆时需要临时使用代理，也可以使用命令行参数实现：

# http/https 代理
git clone --config http.proxy=http://<proxy_address>:<port> <repository_url>

# socks5 代理
git clone --config http.proxy=socks5://<proxy_address>:<port> <repository_url>

注意，SSH 默认不会走 Windows 下的系统代理，更不会走 Linux 的后台代理，因此，如果发现通过 SSH 进行 git clone 时报错，可以排查是否为网络问题。如果是，需要配置 ssh config 并指定代理。以下是 Linux 的 SSH 代理设置方式，需借助 netcat 实现。

Host github.com
  Hostname ssh.github.com
  IdentityFile /home/yzh/.ssh/whr-yzh-git
  User git
  Port 443
  ProxyCommand nc -X 5 -x 127.0.0.1:7890 %h %p

Windows 的 ssh 代理设置方式，见 Windows平台代理OpenSSH

Download | Node.js (nodejs.org)

下载 Linux Binaries (x64)并解压

wget https://nodejs.org/dist/v18.18.0/node-v18.18.0-linux-x64.tar.xz
tar -xJf node-v18.18.0-linux-x64.tar.xz -C /usr/local/

配置环境变量

修改 ~/.bashrc

export PATH=/usr/local/node-v18.18.0-linux-x64/bin:$PATH

执行 source ~/.bashrc 生效

查看效果

node -v
npm -v

[!warning] 如果你是非 root 用户，切记 export 的路径不要用 ~ ，否则会出现 node -v 正常但 npm -v 失败的奇怪情况。原因是 npm 默认情况下是使用 node 去执行的，而你导出的路径为 ~ ，因此系统会去 /usr/bin 下寻找 node 的。而一旦管理员没有安装 node 环境的话，那你是无法使用 node 去调用 npm 的。

使用进程守护工具

这里以 node.js 的 pm2 为例。Deep Leaners 建议跳过这一节。

部署

# 全局安装pm2
npm i pm2 -g  

# 进入项目目录下
pm2 start index.js  --name your-project-any-name

利用该方式可以在服务器上运行多个 Node.js 项目

pm2 命令

nohup

什么是 nohup

在 Unix 和类 Unix 操作系统中，信号是进程间通信的一种方式，用于通知接收进程某个事件已经发生。挂起信号（SIGHUP）是其中的一种。

当终端或控制进程断开时，操作系统会向由该终端启动的进程发送 SIGHUP 信号。默认情况下，大多数进程在接收到 SIGHUP 信号时会终止。这是因为，在早期 Unix 系统中，终端断开通常意味着用户已经“挂断”了电话线，因此与终端相关的进程不再有用。

然而，有时希望即使在终端断开的情况下，进程也能继续运行。这就是 nohup 命令的用途。nohup 命令会忽略 SIGHUP 信号，使得启动的进程在终端断开后继续运行。此外，nohup 还会自动将进程的标准输出和标准错误输出重定向到 nohup.out 文件，以防止输出丢失。

使用方式

这里给出三种指令模板，按需使用：

# 忽略挂起信号, 错误输出和标准输出都被重定向到 `nohup.out`
nohup python your_script.py > output.log 2>&1 &

# 忽略挂起信号, 标准输出都被重定向到 `nohup.out`
nohup python your_script.py > output.log &

# 忽略挂起信号, 但没有指定输出重定向
nohup python your_script.py &

这里的 output.log 可以是任意文本文件，例如 a.txt，b，log.aaa 等，随你喜欢。所以显然，第二种和第三种除了指定输出文件名的区别外，没有其他差异。

有时即使使用了 nohup 和 & 让命令在后台运行，退出 SSH 连接时仍然可能会收到 "you have running jobs" 的提示（实测会发生在 zsh 中）。这是因为退出 shell 会话时，shell 会检测到仍然有在当前 shell 会话中启动的进程（即使它们是后台进程）。

要避免这个问题，可以使用 disown 命令来从当前 shell 的作业列表中删除这些作业，使它们不受当前 shell 会话的影响。例如：

# 执行了某个作业
nohup ./frps -c frps.toml &

# 删除作业记录
disown

这并不影响后台作业的执行。当然，也可以直接关闭 shell 窗口以退出用户登陆。

Tmux

Tmux Docs

[!tip] Win10 已经内置了 openssh 组件，可以直接使用。其他版本自行搜索。

ssh-keygen

回车后会让你设置密钥生成路径以及 phrase 等内容，默认为空即可，一路回车。

然后可以在 C:\Users\你的win用户名\.ssh 下看到 id_rsa 和 id_rsa.pub 两个文件，其中前者为私钥，后者为公钥。

上传公钥

仅 Linux 可用

ssh-copy-id -i ~/.ssh/id_rsa.pub user@host

这里的 user 和 host 对应需要免密连接的服务器的用户和 IP 地址。

通用方法

通过 scp，或者 sftp，或者其他什么方式，将公钥 id_rsa.pub 文件的内容粘贴到服务器的 ~/.ssh/authorized_keys 文件中。

[!warning] 如果你想在服务器上存放多个公钥文件，请保证每个公钥在 authorized_keys 文件中单独占一行。如果使用 ssh-copy-id 则可以忽略此处。

配置本地 ssh

ssh 配置文件地址：

# windows
C:\Users\你的win用户名\.ssh\config

# Linux
~/.ssh/config

在配置文件中添加如下内容：

Host 自定义名称
  HostName 服务器的IP/域名
  User 登录用户名
  IdentityFile C:\Users\你的win用户名\.ssh\id_rsa

[!tip] 此处的 IdentityFile 为私钥路径，即 id_rsa

然后就可以在 Terminal 中实现免密 ssh 访问服务器

ssh 自定义名称

备注

也许你会发现，通过 ssh-copy-id 命令或者别的什么方式，将公钥添加到远程服务器的 authorized_keys 文件中后，即使并且没有在本地 SSH 配置文件中显式指定 IdentityFile 字段，但仍然可以成功进行免密连接。

这是因为 SSH 客户端会默认使用 ~/.ssh/id_rsa（默认私钥文件）来进行身份验证。

SSH 客户端在尝试连接时会按照一定的顺序搜索可用的私钥文件，其中包括默认的 ~/.ssh/id_rsa 文件。因此，如果你的私钥文件恰好是默认的 ~/.ssh/id_rsa，那么在本地 SSH 配置文件中不显式指定 IdentityFile 字段也可以进行免密连接。

虽然在某些情况下可以省略 IdentityFile 字段，但为了确保连接的稳定性和安全性，建议在本地 SSH 配置文件中明确指定要使用的私钥文件路径。这样可以避免混淆和不必要的问题，并确保连接设置是清晰明了的。

但是这分明是给 Linux 用的， Windows 上哪里来的 nc 程序？

所以以下操作才是给 Windows 用的。

在自己的用户文件夹找到 .ssh 文件夹，在里面新建一个空白文件，取名 config，如果已经有了就不用创建了。

在 config 文件加上：

Host 自定义名称
  HostName 服务器的IP/域名
  User 登录用户名
  IdentityFile C:\Users\你的win用户名\.ssh\id_rsa
  ProxyCommand "D:\environment\Git\mingw64\bin\connect.exe" -S 127.0.0.1:7890 %h %p  

这里 git 的安装路径和后面的代理自己看着填。后面的代理， -S 指是 socks 代理，默认是 socks5， 127.0.0.1:7890 就是你本地的代理地址，后面的 %h %p 意思是 Host 和 Port。如果要使用 HTTP 代理，就写 -H 。

当然，不难发现这里其实调用的是 Git 中的 connect.exe 程序，如果没有或者不想安装 Git，完全可以用独立程序代替，下载方式如下：

scoop install main/connect

由于这个程序已经相当古老了，因此只能在互联网存档中找到。

双方的最低计费门槛为 0.01 元，即低于 0.01 元的消费直接算作 0 元(免费)。双方按量付费规则如下：

• 阿里云：
  • 按小时计费
  • 存储费用=存储量（GB）×月单价÷30（天）÷24（小时）
• 腾讯云：
  • 按天计费，日存储容量费用 = 存储容量月单价 / 30 * 日存储容量
  • 日存储容量 = 当日“每5分钟存储容量”之和 / 288（采样点数）

综上可计算出双方触发计费门槛时的最低存储容量：

也就是你最多可以白嫖这么大的空间（只是存储不计费，流量还是贵）

• 阿里云：$0.01 \div (0.12 \div 30 \div 24) = 59.9999 \approx 60(GB)$
• 腾讯云：$0.01 \div (0.099 \div 30) = 3.0303 \approx 3.03(GB)$

我自认为算的没错，但没想到相差会这么大。。。

关于腾讯云采样点的解释

假设你存了 $x$ GB 的数据，并且在一天时间内保持不变，那么你的日存储容量为：

$$ StoragePerDay = (1 \times 24 \times 60 \div 5)x \div 288 = x $$

也就是“每 5 分钟采样一次”正好对应 288 个采样点。之所以这么计算是为了当你的存储容量发生变动时，能够快速的调整之后的存储费用。

中国大陆外

以香港为例

CDN

按量计费

这里因为是自用，所以只考虑中国内地

阿里

腾讯

双方都是阶梯计费，但腾讯云最高档位也比阿里云便宜。

关于 CDN 计费规则

cdn 计费图示意，OSS/COS 通用

从上图可知，对象存储加上 CDN 后，主要产生的计费项目变化如下：

1. 用户上传到 OSS/COS 依然免费
2. 用户从对象存储下载资源时，访问路径从 用户-OSS/COS 变成了 用户-CDN-OSS/COS，因此：
   1. 加上 CDN 后肯定会把对象存储设置为私有读写，此时原来从 OSS/COS 直接流向用户(公网)的流量就变成了 CDN 的回源流量（0.5 元/GB -> 0.15 元/GB）
   2. 用户只会和 CDN 交互，因此会产生 CDN 的下行流量费用（0.21 元/GB）

综上所述，假设同样要从对象存储下载 1GB 数据（这里忽略请求等费用，只考虑流量费用）：

• 不使用 CDN：0.5 元
• 使用 CDN 但未命中 CDN 缓存：0.21+0.15=0.36 元
• 使用 CDN 且命中 CDN 缓存：0.21

使用 CDN 除了流量费用变得便宜，更重要的是以下两点：

1. 对象存储本质上相当于你的一个私有存储，公开对外访问本就是存在严重安全隐患的
2. 各大厂商针对 CDN 都有比对象存储更完善的安保报警机制，当发生盗刷时能够及时通知并下线 CDN，因此更安全

   及不及时不好说，但起码能够下线 CDN，个人用户设置几个 G 的阈值，真盗刷了也用不了几个钱。更何况还有防盗链之类的，虽然 ob 不支持 hhh。

[!warning] COS 重大发现 他妈的，人家腾讯 COS 不用设置自定义域名就可以实现在线预览，这 TM 才叫图床！ 已经不能用了 hhh

当前使用方案总结

1. 腾讯云 CDN + 阿里云 OSS （肯定挑便宜大碗的用，没毛病）
2. CDN 设置单日封顶以及5分钟内封顶，触发报警后 CDN 永久离线

TODO

根据官方文档，有一种模式也许可以进一步节省流量。将对象存储挂载到厂商同地域的云服务器，这样对象存储的流量传输全部走内网，属于免费。然后对服务器套上（全站）CDN，如此一来只会产生 CDN 下行流量。

不过受限于国内价比黄金的带宽，如果访问量较高且触发回源的话，可能会因为小水管的原因收到阻塞。

理论上说，学校是可以给教职工服务器开通外网访问权限的。。。咱不敢问，也不敢说，所以还是自己动手丰衣足食吧，反正对于法外狂徒来说，代理只是家常便饭了。

clash dashboard 面板密码：yzh112358

代理程序的二进制文件位于服务器的 /usr/local/bin/mihomo。

配置文件位于 /etc/mihomo，结构如下：

mihomo/
├── cache.db  缓存
├── config.yaml  配置文件
├── Country.mmdb  geoip数据库
├── providers/  规则集
└── ui/  web面板

你需要知道

1. 什么是代理？和 VPN 有什么区别？
2. 什么是“机场”？

为了避免上述链接失效或无法直连访问，已将对应页面归档为 .WACZ。打开该文件，可以通过 Webrecorder ArchiveWeb.page 浏览器插件，见 webarchive.zip

/root/release下是一些公共服务的二进制文件

部署 clash

1. 下载二进制文件(自行根据最新版本修改指令)，并解压

   wget https://ghproxy.085404.xyz/https://github.com/MetaCubeX/mihomo/releases/download/Prerelease-Alpha/mihomo-linux-amd64-alpha-1d3e9f4.gz
   gzip -d mihomo-linux-amd64-alpha-1d3e9f4.gz
   

2. 将下载的二进制可执行文件重名名为 mihomo 并移动到 /usr/local/bin/

   mv mihomo-linux-amd64-alpha-1d3e9f4.gz mihomo
   cp mihomo /usr/local/bin
   

3. 下载配置文件并复制到对应路径下

   curl -o config.yaml "你的订阅链接"
   cp config.yaml /etc/mihomo
   

4. 授予合适的权限后，启动 clash

   # -d 是配置文件路径，-h 可查看完整文档
   nohup mihomo -d /etc/mihomo > clash.log 2>&1 &
   

说明

1. config.yaml, cache.db, Country.mmdb 授予组读写权限
2. mihomo 授予组执行权限
3. 通过 nohup 挂起后，日志会写入 clash.log 文件，而 dashboard 中无法查看

   想了想，反正 dashboard 的日志界面说实话很一般，真要分析还是看日志文件吧。。。主要是非root启动更安全。如果实在无法接受，通过 systemd 启动服务即可正常使用，见 虚空终端

部署 clash dashboard

git clone https://github.com/metacubex/metacubexd.git -b gh-pages /etc/mihomo/ui

更新方式：

cd /etc/mihomo/ui
git pull -r
# 或者
git -C /etc/mihomo/ui pull -r

而后通过 nginx 反向代理，或者访问 http://ip:9090/ui都可以。

这个端口具体看配置文件的 external-controller

frp GitHub

frp 中文文档

事件背景

公元 2024 年，傻逼校园网屏蔽了内网不同网段设备的访问，导致我的所有局域网解决方案全部失效（例如 alist）。至此，我无法躺在宿舍的床上看实验室里电脑的视频，这极大的影响了我的科研热情。为此，决定进行内网穿透。

本次进行的内网穿透主要针对 http 服务（alist）。

服务端配置

下述内容也可以参考官方示例 vhost-http

# 下载 frp
wget https://github.com/fatedier/frp/releases/download/v0.54.0/frp_0.54.0_linux_amd64.tar.gz
# 解压
tar -zxvf frp_0.54.0_linux_amd64.tar.gz

注意，frp 的 Github Release 内包括客户端与服务端两部分，分别对应 frps* 于 frpc*。所以服务端配置可以删除 frpc*。

此外，麻烦还在无脑搬运的看看这个："从 v0.52.0 版本开始，frp 开始支持 TOML、YAML 和 JSON 作为配置文件格式。请注意，INI 已被弃用，并将在未来的发布中移除。新功能只能在 TOML、YAML 或 JSON 中使用。希望使用这些新功能的用户应相应地切换其配置格式。"—— frps docs

服务端 frps.toml 内容如下：

bindPort = 7000 # frp 服务端口
vhostHTTPPort = 5245 # 监听 HTTP 的端口

请确保关闭这两个端口的防火墙。

客户端配置

serverAddr = "172.16.16.242" # 服务端 IP
serverPort = 7000 # 服务端 frp 服务端口

[[proxies]] # 可写可不写，不影响
name = "alist" # 需唯一
type = "http"
localPort = 5244  # 本地 http 服务的端口
customDomains = ["your_domain.com"]

针对该配置文件做出补充介绍：

1. 不难发现我这里的 serverAddr 并不是一个公网 IP，而是一个内网 IP。因为校园网屏蔽了外网 IP，导致我的新加坡服务器无法作为内网穿透的服务端，因此退而求其次使用了一台内网服务器作为服务端。因此严格来说，本次实践是进行的内网的内网穿透。
2. customDomains 是一个 A 记录解析到 serverAddr 的域名。参考官方文档，DomainConfig 有 customDomains 和 subdomain 两个配置项。实测必须指定一个，否则会报错 proxy xxx: subdomain and custom domains should not be both empty

启动 frp 服务

启动服务端：

./frps -c frps.toml

服务端成功启动后，会看到如下类似信息：

2024/02/25 19:41:14 [I] [root.go:105] frps uses config file: frps.toml
2024/02/25 19:41:15 [I] [service.go:225] frps tcp listen on 0.0.0.0:7000
2024/02/25 19:41:15 [I] [service.go:292] http service listen on 0.0.0.0:5245
2024/02/25 19:41:15 [I] [root.go:114] frps started successfully

启动客户端：

.\frpc.exe -c .\frpc.toml

客户端启动成功后，会看到如下类似信息：

2024/02/25 19:42:52 [I] [root.go:142] start frpc service for config file [.\frpc.toml]
2024/02/25 19:42:52 [I] [service.go:287] try to connect to server...
2024/02/25 19:42:52 [I] [service.go:279] [7e047f197c32f772] login to server success, get run id [7e047f197c32f772]
2024/02/25 19:42:52 [I] [proxy_manager.go:173] [7e047f197c32f772] proxy added: [alist]
2024/02/25 19:42:52 [I] [control.go:170] [7e047f197c32f772] [alist] start proxy success

此时服务端也会同步显示客户端连接情况：

2024/02/25 19:42:54 [I] [service.go:563] [7e047f197c32f772] client login info: ip [172.26.109.89:1557] version [0.54.0] hostname [] os [windows] arch [amd64]
2024/02/25 19:42:54 [I] [http.go:110] [7e047f197c32f772] [alist] http proxy listen for host [your_domain.com] location [] group [], routeByHTTPUser []
2024/02/25 19:42:54 [I] [control.go:401] [7e047f197c32f772] new proxy [alist] type [http] success

访问内网服务

通过 http://your_domain.com:5245 即可访问内网设备 127.0.0.1 下端口 5244 的服务。

客户端配置中，localIP 默认为 127.0.0.1，故省略。如有需要请自行修改。

核心概念

Node

Neo4j 图形数据库中的数据实体称为节点。 Cypher 中使用括号 ( ) 引用节点。

MATCH (n:Person {name:'Anna'})
RETURN n.born AS birthYear

在上述例子中：

• Person 是一个 label（标签）。标签就像标记一样，用于在数据库中查询特定节点。一个节点可以有多个标签，例如张三可以是 Person，也可以是 Actor
• 节点的 name 属性设置为 Anna 。属性在大括号 { } 内定义，用于为节点提供特定信息，也可以查询这些信息并进一步提高精确定位数据的能力
• 赋予该节点变量 n 。变量允许在后续子句中引用指定的节点

Relationship

图中的节点可以通过关系连接起来。关系必须具有起始节点、结束节点和一种类型（三元组）。关系在 Cypher 中用箭头（例如 --> ）表示，指示关系的方向。

MATCH (:Person {name: 'Anna'})-[r:KNOWS WHERE r.since < 2020]->(friend:Person)
RETURN count(r) As numberOfFriends

与节点不同，关系模式中的信息必须用方括号 [ ] 括起来。

所以一个关系应该形如 node1-[ var:type ]->node2 或者 node1<-[ var:type ]-node2， 即用一个 [ ] 插在 --> 的两个横线中间

上面的查询示例表示：匹配 type (类型)为 KNOWS 且属性 since 小于 2020 的关系。并且该关系应该从名为 Anna 的 Person 节点指向任何其他的 Person 节点（赋予变量 friend ）。

count() 函数在 RETURN 子句中用于统计前面 MATCH 子句中 r 变量绑定的所有关系（即有多少个朋友在 2020 之前就已经认识了）。

label 和 type 从作用上都可以近似理解为“类型”。 但请注意：虽然节点可以有多个标签，但关系只能有一种类型。

Path

图中的路径由连接的节点和关系组成。探索这些路径是 Cypher 的核心。

MATCH (n:Person {name: 'Anna'})-[:KNOWS]-{1,5}(friend:Person WHERE n.born < friend.born)
RETURN DISTINCT friend.name AS olderConnections

此示例使用量化关系来查找距离 5-hops 的所有路径，仅遍历从起始节点 Anna 到其他旧 Person 类型（由 WHERE 子句定义）的 KNOWS 关系。DISTINCT 运算符用于确保 RETURN 子句仅返回唯一节点。

Match

获取所有节点

通过指定具有单个节点且没有标签的模式，将返回图中的所有节点。

MATCH (n)
RETURN n

查找具有特定标签的所有节点：

MATCH (movie:Movie)
RETURN movie.title

查找相关节点

相关节点即具有关系连接的节点。符号 -- 表示与关系相关，而不考虑关系的类型或方向。

MATCH (director {name: 'Oliver Stone'})--(movie)
RETURN movie.title

返回 Oliver Stone 执导的所有电影

通过标签约束查找

匹配名为 Oliver Stone 的 Person 的连接的所有 Movie 节点。

MATCH (:Person {name: 'Oliver Stone'})--(movie:Movie)
RETURN movie.title

也可以通过标签表达式进行约束

MATCH (n:Movie|Person)
RETURN n.name AS name, n.title AS title

返回 Movie or Person 节点。

指向性查找

使用 --> 或者 <-- 可以查找 outgoing relationship（出链、出关系）：

MATCH (:Person {name: 'Oliver Stone'})-->(movie)
RETURN movie.title

返回通过出关系连接到 Person 节点且 name 属性设置为 Oliver Stone 的任何节点。

关系变量

可以向模式引入变量，用于过滤关系属性或返回关系。例如：

MATCH (:Person {name: 'Oliver Stone'})-[r]->(movie)
RETURN type(r)

返回 Oliver Stone 中每个传出关系的类型。

匹配无向关系

当模式包含绑定关系，并且该关系模式未指定方向时，Cypher 将尝试在两个方向上匹配该关系。

MATCH (a)-[:ACTED_IN {role: 'Bud Fox'}]-(b)
RETURN a, b

Create

创建节点

CREATE (charlie:Person:Actor {name: 'Charlie Sheen'}), (oliver:Person:Director {name: 'Oliver Stone'})

创建两个节点，绑定到变量 charlie 和 oliver，每个节点都有一个 Person 标签和 name 属性。此外，charlie 节点还具有标签 Actor，而 oliver 节点则分配有标签 Director。

点击 ▶ 执行或 Ctrl + Enter shift + enter 换行输入

创建关系

使用 CREATE 子句创建关系。与节点不同，关系始终只需要一种关系类型和方向。与节点类似，可以为关系分配属性和关系类型，并绑定到变量。

CREATE (charlie:Person:Actor {name: 'Charlie Sheen'})-[:ACTED_IN {role: 'Bud Fox'}]->(wallStreet:Movie {title: 'Wall Street'})<-[:DIRECTED]-(oliver:Person:Director {name: 'Oliver Stone'})

此查询为 Charlie Sheen 和 Oliver Stone 创建 Person 节点，为 Wall Street 创建 Movie 节点。它还创建了它们之间的类型 ACTED_IN 和 DIRECTED 的关系。

注意两个箭头的指向，分别是 -[ ]-> 和 <-[ ]-

对已存在节点创建关系

match (a:`品种`),(b:area) where a.name="爆裂葡萄" and b.location="(114,514)" create (a)-[r:plant_in]->(b) return r

试想，对已存在的节点添加关系，需要经历三步：

1. 找出头节点、尾节点 match (a),(b) where ...
2. 确定两者之间的关系 relation type
3. 建立关系 create (a)-[r:type]->(b)

[!question] 如果直接节点、关系一把抓，一起创建，会发生什么？

create (:`品种`{name:"爆裂葡萄"})-[:plant_in]->(:area{location:"(114,514)"})

执行上述操作后，会生成两个新节点与它们之间的关系，即使目标品种与位置已经存在，仍会执行节点创建操作，这很可能是我们不想要的。

Delete

删除单个节点

MATCH (n:Person {name: 'Tom Hanks'})
DELETE n

这将删除 Person 节点 Tom Hanks 

该查询只能在没有任何关系连接的节点上运行

还可以使用 NODETACH DELETE 子句删除单个节点。使用 NODETACH 关键字显式定义关系不会从节点分离并删除。 NODETACH 关键字是现有关键字 DETACH 的镜像。包含它在功能上与使用简单的 DELETE 相同。

MATCH (n:Person {name: 'Tom Hanks'})
NODETACH DELETE n

NODETACH 在 Neo4j 5.14 中引入

仅删除关系

删除关系的同时保持连接到该关系的节点不受影响。

MATCH (n:Person {name: 'Laurence Fishburne'})-[r:ACTED_IN]->()
DELETE r

这将从 Person 节点 Laurence Fishburne 删除所有传出的 ACTED_IN 关系，而不删除该节点。

删除节点及其所有关系

要删除节点以及连接它们的任何关系，需使用 DETACH DELETE 子句。

MATCH (n:Person {name: 'Carrie-Anne Moss'})
DETACH DELETE n

这将删除 Person 节点 Carrie-Anne Moss 以及与其连接的所有关系。

安全权限受限的用户可能不允许使用 DETACH DELETE 子句。有关详细信息，RTFM -> 细粒度访问控制

删除所有节点和关系

MATCH (n)
DETACH DELETE n

不适用于删除大量数据，但在试验小型示例数据集时很有用。当删除大量数据时，请使用 CALL { …​ } IN TRANSACTIONS

Load CSV

介绍

• CSV 文件的 URL 是通过使用 FROM 指定的，后跟计算相关 URL 的任意表达式
• 需要使用 AS 为 CSV 数据指定变量
• CSV 文件可以存储在数据库服务器上，然后可以使用 file:/// URL 进行访问。另外， LOAD CSV 还支持通过 HTTPS、HTTP 和 FTP 访问 CSV 文件
• LOAD CSV 支持使用 gzip 和 Deflate 压缩的资源。此外， LOAD CSV 支持本地存储的使用 ZIP 压缩的 CSV 文件
• LOAD CSV 将遵循 HTTP 重定向，但出于安全原因，它不会遵循更改协议的重定向，例如，从 HTTPS 转到 HTTP
• LOAD CSV 通常与子查询 CALL { …​ } IN TRANSACTIONS 结合使用
• LOAD CSV 由加载权限 Load Privileges 调节

文件 URL 的配置

dbms.security.allow_csv_import_from_file_urls

使用 LOAD CSV 加载数据时 Cypher 是否允许使用 file:/// URL 加载数据库服务器文件系统上的文件。默认为 true。

设置 dbms.security.allow_csv_import_from_file_urls=false 将完全禁用 LOAD CSV 对文件系统的访问。

server.directories.import

设置 file:/// URL 的根目录。应将其设置为相对于数据库服务器上 Neo4j 安装路径的单个目录。所有从 file:/// URL 加载的请求都将相对于指定的目录。

配置设置中设置的默认值是 import。这是一种安全措施，可防止数据库访问标准导入目录之外的文件，类似于 Unix chroot 的操作方式。将其设置为空字段将允许访问 Neo4j 安装文件夹中的所有文件。注释掉此设置将禁用安全功能，从而允许导入本地系统中的所有文件。这绝对不推荐。

文件 URL 将相对于 server.directories.import 目录进行解析。例如，文件 URL 通常类似于 file:///myfile.csv 或 file:///myproject/myfile.csv。请注意：

• 使用 file:/// URL 时，空格和其他非字母数字字符需要进行 URL 编码
• 如果 server.directories.import 设置为默认值 import，则在 LOAD CSV 中使用上述 URL 将分别从 <NEO4J_HOME>/import/myfile.csv 和 <NEO4J_HOME>/import/myproject/myfile 读取.csv
• 如果设置为 /data/csv，则在 LOAD CSV 中使用上述 URL 将分别从 <NEO4J_HOME>/data/csv/myfile.csv 和 <NEO4J_HOME>/data/csv/myproject/myfile.csv 读取

server.directories.import 仅适用于本地磁盘，不适用于远程 URL

csv 文件格式

• 字符编码为 UTF-8
• 结束行终止取决于系统，例如，在 UNIX 上为 \n ，在 Windows 上为 \r\n
• 默认字段终止符是 ,。可使用 LOAD CSV 命令中的选项 FIELDTERMINATOR 更改字段终止符
• CSV 文件中允许带引号的 STRING 值，并且在读取数据时会删除引号；
• STRING 引号的字符是双引号 " 
• 如果 dbms.import.csv.legacy_quote_escaping 设置为 true 的默认值，则 \ 用作转义字符
• 双引号必须位于带引号的 STRING 中并使用转义字符或第二个双引号进行转义

• headers 最好设置英文，反正 line.'名称' 这种写法是会报错的

从 csv 导入数据

无标题 csv

使用 LOAD CSV 将数据获取到查询中。然后使用 Cypher 的正常更新子句将其写入数据库。

1,ABBA,1992
2,Roxette,1986
3,Europe,1979
4,The Cardigans,1992

为 CSV 文件中的每一行创建一个带有 Artist 标签的新节点，CSV 文件中的两列被设置为节点上的属性：

LOAD CSV FROM 'file:///artists.csv' AS line
CREATE (:Artist {name: line[1], year: toInteger(line[2])})

也可以导入远程 csv：

LOAD CSV FROM 'https://data.neo4j.com/bands/artists.csv' AS line
CREATE (:Artist {name: line[1], year: toInteger(line[2])})

有标题 csv

Id,Name,Year
1,ABBA,1992
2,Roxette,1986
3,Europe,1979
4,The Cardigans,1992

使用 WITH HEADERS 表示文件首行为列名，可以通过相应的列名称访问特定字段：

LOAD CSV WITH HEADERS FROM 'file:///artists-with-headers.csv' AS line
CREATE (:Artist {name: line.Name, year: toInteger(line.Year)})

自定义 csv 分隔符

有时，CSV 文件使用逗号以外的其他分隔符。此时可以使用 FIELDTERMINATOR 指定文件使用的分隔符。

FIELDTERMINATOR = field terminator

如果前面加上 \u，则可以使用 unicode 字符编码的十六进制表示形式。编码必须用四位数字书写。例如，\u003B 相当于 ; (分号)。

1;ABBA;1992
2;Roxette;1986
3;Europe;1979
4;The Cardigans;1992

LOAD CSV FROM 'file:///artists-fieldterminator.csv' AS line FIELDTERMINATOR ';'
CREATE (:Artist {name: line[1], year: toInteger(line[2])})

导入大量数据

如果 CSV 文件包含大量行（接近数十万或数百万），则可以使用 CALL { ... } IN TRANSACTIONS 指示 Neo4j 在多行之后提交事务。这可以减少事务状态的内存开销。

也可以设置事务的速率，例如加上 OF 500 ROWS 表示 500 行为一个事务。

LOAD CSV FROM 'file:///artists.csv' AS line
CALL {
  WITH line
  CREATE (:Artist {name: line[1], year: toInteger(line[2])})
} IN TRANSACTIONS OF 500 ROWS

导入包含转义字符的数据

当数据周围都有额外的引号，甚至值内还有转义引号时：

"1","The ""Symbol""","1992"

"The ""Symbol""" = The "Symbol"

LOAD CSV FROM 'file:///artists-with-escaped-char.csv' AS line
CREATE (a:Artist {name: line[1], year: toInteger(line[2])})
RETURN
  a.name AS name,
  a.year AS year,
  size(a.name) AS size

返回结果如下：

请注意，输出中的 STRING 值用引号 ' 包裹

获取行号

对于某些情况，例如调试 csv 文件时，获取 LOAD CSV 正在运行的当前行号可能很有用。 

linenumber() 函数提供了该功能，或者如果在没有 LOAD CSV 上下文的情况下调用，则返回 null 。

LOAD CSV FROM 'file:///artists.csv' AS line
RETURN linenumber() AS number, line

+---------------------------------------+
| number | line                         |
+---------------------------------------+
| 1      | ["1","ABBA","1992"]          |
| 2      | ["2","Roxette","1986"]       |
| 3      | ["3","Europe","1979"]        |
| 4      | ["4","The Cardigans","1992"] |
+---------------------------------------+
4 rows

获取绝对路径

与 linenumber() 类似，如果在没有 LOAD CSV 上下文的情况下调用，则返回 null。

LOAD CSV FROM 'file:///artists.csv' AS line
RETURN DISTINCT file() AS path

由于 LOAD CSV 可以临时下载文件来处理，因此需要注意的是 file() 将始终返回磁盘上的路径。如果使用指向磁盘的 file:/// URL 调用 LOAD CSV，file() 将返回相同的路径。

FAQ

导出 cypher

:history

然后导出即可

最小权限原则（Principle of Least Privilege, POLP）是一种在计算机安全领域广泛遵循的原则，其核心理念是：任何用户、进程、程序或系统组件都应仅拥有执行其任务所必需的最小范围内的权限。换句话说，不应授予比完成工作所需的更多访问权或特权。

具体来说：

• 每个用户账号应当只被赋予完成其职责所必要的账户权限，例如，如果一个用户只需要读取特定文件，则不应授予其写入或删除该文件的权限。
• 应用程序和服务应当以非管理员或最少特权用户身份运行，除非它们确实需要进行系统级别的操作。
• 系统配置和策略应当限制不必要的资源访问，确保即使有恶意软件或内部误操作发生时，攻击面也能保持最小化。

通过实施最小权限原则，可以有效减少潜在的安全威胁，因为即便某个部分遭到破坏，其损害也会受限于其所拥有的权限级别。这有助于防止恶意活动扩散，并保护敏感信息不被未经授权的访问或修改。

用户

切换到其他用户

变更帐号为 root 并在执行 ls 指令后退出变回原使用者：

su -c ls root

变更帐号为 test 并改变工作目录至 test 的家目录：

su - test

从 root 用户切换为之前的普通用户只需要 exit 即可。

修改密码

普通用户修改自己的密码

passwd

root 用户修改其他用户密码

passwd user_name

如果修改密码过程中不想修改了，可以尝试 ctrl + c 或者 ctrl + d 退出

锁定某个用户的密码（让他不能修改）：

# 锁定
passwd -l user_name
# 解除锁定
passwd -u user_name

删除用户密码（则登录时无需密码）：

passwd -d user_name

用户组

将用户归为特定的组并设置路径权限

创建组

首先，如果A组和B组还不存在，你可以使用 groupadd 命令来创建它们：

sudo groupadd groupA
sudo groupadd groupB

将用户添加到组中

使用 usermod 命令将用户添加到所需的组中。例如，将用户 user1 添加到 groupA：

sudo usermod -aG groupA user1

同样地，将用户 user2 添加到 groupB：

sudo usermod -aG groupB user2

在这个命令 sudo usermod -aG groupA user1 中：

• -a: 这个选项是 "append" 的缩写。使用 -a 选项意味着你想要向用户的现有组（以及其他组）中添加一个新的组，而不是替换掉现有的组。
• G: 这个选项告诉 usermod 命令你要修改用户的组关联。

因此，-aG 组合选项的作用是将指定用户添加到指定的组（在此例中是 groupA）中，而不会影响该用户的其他组关联。

如果想要让某个文件/路径A组可读写，B组可读，单纯通过 chmod 无法实现，需要借助更高级的权限管理工具。因此一种常规的做法是，将同一个用户添加到多个组中，通过对组的权限进行设置，实现复杂权限控制。

如果你想要将当前用户（即你正在使用的用户）移动到一个特定的组中，你可以使用 usermod 命令。但是需要小心，这样做可能会导致一些权限问题，因为用户现有的文件和目录可能是基于之前的主组创建的。所以，在更改用户的主组后，确保适当地调整文件和目录的权限，以确保用户在新的主组中有所需的权限。

要将当前用户（例如，假设当前用户是 user1）移动到 groupA 组，你可以执行以下命令：

sudo usermod -g groupA user1

设置路径权限

使用 chmod 和 chown 命令来设置路径的权限。例如，如果你有一个名为 /path/to/your/directory 的目录，并且你想让 groupA 的用户有对该目录的读写权限，而 groupB 的用户只有读权限，你可以执行以下操作：

1. 设置目录 所有者:组：

sudo chown user1:groupA /path/to/your/directory

所有者和组没有必然联系，所有者未必是属于这个组的。

1. 设置目录的权限为允许 groupA 读写，但只允许 groupB 读：

sudo chmod 770 /path/to/your/directory

现在，只有属于 groupA 的用户可以读取、写入和执行 /path/to/your/directory。其他用户（不是所有者也不属于 groupA 的用户）则不能访问这个目录。

1. 设置ACL (可选)： 如果你想为特定的组或用户设置更细粒度的权限控制，可以考虑使用ACL（访问控制列表）。这允许你设置文件或目录的详细权限规则。

修改所属组

# 修改所属用户
sudo chown 新所有者用户名 文件或目录路径
# 修改所属组
sudo chown :新组名 文件或目录路径
# 同时修改所属用户和所属组
sudo chown 新所有者用户名:新组名 文件或目录路径

Linux 权限说明

在Linux和UNIX系统中，文件和目录的权限可以使用数字形式表示。这些数字是通过组合不同的权限标志来构成的。

每个权限标志对应一个特定的数值：

• r（读取权限）：对应数值 4
• w（写入权限）：对应数值 2
• x（执行权限）：对应数值 1

为了设置文件或目录的权限，你可以为所有者、组和其他用户分别分配上述的权限数值。当你将这些数值相加，就可以得到完整的三位数字表示权限。

举例来说，如果你看到一个权限设置是 770，它可以被分解为：

• 第一个数字 7：代表所有者的权限。这是通过将 rwx 转换为对应的数值进行计算得到的，即 4 (读) + 2 (写) + 1 (执行) = 7。
• 第二个数字 7：代表所属组（即属于该组的其他用户）的权限。同样，它也是 rwx，即 4 (读) + 2 (写) + 1 (执行) = 7。
• 第三个数字 0：代表其他用户（不是文件或目录的所有者或同组的用户）的权限。这里为 0 意味着没有任何权限。

授权指令chmod

https://www.runoob.com/linux/linux-comm-chmod.html

语法

chmod [-cfvR] [--help] [--version] mode file...

参数说明

mode : 权限设定字串，格式如下 :

[ugoa...][[+-=][rwxX]...][,...]

其中：

• u 表示该文件的拥有者，g 表示与该文件的拥有者属于同一个群体(group)者，o 表示其他以外的人，a 表示这三者皆是。
• + 表示增加权限、- 表示取消权限、= 表示唯一设定权限。
• r 表示可读取，w 表示可写入，x 表示可执行，X 表示只有当该文件是个子目录或者该文件已经被设定过为可执行。

其他参数说明：

• -c : 若该文件权限确实已经更改，才显示其更改动作
• -f : 若该文件权限无法被更改也不要显示错误讯息
• -v : 显示权限变更的详细资料
• -R : 对目前目录下的所有文件与子目录进行相同的权限变更(即以递归的方式逐个变更)
• --help : 显示辅助说明
• --version : 显示版本

示例

# 给 /test/a 的所有者添加执行权限
chmod u+x /test/a
# 所有人可读、写、执行 /test/a
chmod 777 /test/a

查看当前系统的用户/组情况

要查看当前系统上的所有组和用户，你可以使用以下命令：

1. 查看所有组：

你可以查看 /etc/group 文件来列出所有的组。这个文件包含了系统上的所有组的信息。

cat /etc/group

或者使用以下命令，它会输出更加简洁的组列表：

getent group

1. 查看所有用户：

你可以查看 /etc/passwd 文件来列出所有的用户。这个文件包含了系统上的所有用户的信息。

cat /etc/passwd

但是，如果你只想查看系统用户而不包括系统服务用户（通常UID < 1000的用户），你可以使用以下命令：

awk -F':' '$3 >= 1000 && $3 != 65534 { print $1 }' /etc/passwd

这个命令使用了 awk 工具来过滤 UID 在 1000 或以上的用户，并排除了通常用于系统服务的用户（如 nobody）。

1. awk：这是一个文本处理工具，用于对文本文件进行数据提取和处理。
2. -F':'：这是 awk 命令的一个选项，它告诉 awk 使用 : 作为字段分隔符。在这里，我们正在处理 /etc/passwd 文件，该文件使用 : 来分隔不同的字段。
3. '$3 >= 1000 && $3 != 65534 { print $1 }'：
   • '$3 >= 1000：这个条件检查第三个字段（即用户 ID，UID）是否大于或等于 1000。
   • &&：这是一个逻辑与操作符，用于结合多个条件。
   • $3 != 65534：这个条件确保 UID 不是 65534。通常，这个 UID 被 nobody 用户使用，所以我们排除它。
   • { print $1 }：当上述条件都满足时，执行这个动作，打印出第一个字段，也就是用户名。
4. /etc/passwd：这是我们想要处理的文件路径，它通常包含系统上所有用户的列表及其相关信息。

查看当前用户进程

# u: 显示用户、启动进程的时间和命令, x: 显示没有控制终端的进程
ps ux
# 筛选
ps ux | grep 'python main.py'

基本思想

分支限界法类似于回溯法，也是在问题的解空间上搜索问题解的算法。一般情况下，分支限界法与回溯法的求解目标不同。回溯法的求解目标是找出解空间中满足约束条件的所有解，而分支限界法的求解目标则是找出满足约束条件的一个解，或是在满足约束条件的解中找出使某一目标函数值达到极大或极小的解，即在某种意义下的最优解。

由于求解目标不同，导致分支限界法与回溯法对解空间的搜索方式也不相同。回溯法以深度优先的方式搜索解空间，而分支限界法则以广度优先或以最小耗费优先的方式搜索解空间。

分支限界法的搜索策略是，在扩展结点处，先生成其所有的儿子结点（分支），然后再从当前的活结点表中选择下一个扩展结点。为了有效地选择下一扩展结点，加速搜索的进程，在每一活结点处，计算一个函数值（限界），并根据函数值，从当前活结点表中选择一个最有利的结点作为扩展结点，使搜索朝着解空间上有最优解的分支推进，以便尽快地找出一个最优解。这种方法称为分支限界法。

在搜索问题的解空间树时，分支限界法与回溯法的主要区别在于它们对当前扩展结点所采用的扩展方式不同。在分支限界法中，每一个活结点只有一次机会成为扩展结点。活结点一旦成为扩展结点，就一次性产生其所有儿子结点。在这些儿子结点中，导致不可行解或导致非最优解的儿子结点被舍弃，其余儿子结点被加入活结点表中。此后，从活结点表中取下一结点成为当前扩展结点，并重复上述结点扩展过程。这个过程一直持续到找到所需的解或活结点表为空时为止。

从活结点表中选择下一扩展结点的不同方式导致不同的分支限界法。最常见的有以下两种方式:

1. 队列式(FIFO)分支限界法：队列式分支限界法将活结点表组织成一个队列，并按队列的先进先出原则选取下一个结点为当前扩展结点。
2. 优先队列式分支限界法：优先队列式的分支限界法将活结点表组织成一个优先队列，并按优先队列中规定的结点优先级选取优先级最高的下一个结点成为当前扩展结点。

布线问题

问题定义

印刷电路板将布线区域划分成 $n\times m$ 个方格阵列，如图(a)所示。精确的电路布线问题要求确定连接方格 a 的中点到方格 b 的中点的最短布线方案。在布线时，电路只能沿直线或直角布线，如图(b)所示。为了避免线路相交，已布了线的方格做了封锁标记，其他线路不允许穿过被封锁的方格。

算法思想

布线问题的解空间是一个图。解此问题的队列式分支限界法从起始位置 a 开始将它作为第一个扩展结点。与该扩展结点相邻并且可达的方格成为可行结点被加入到活结点队列中，并且将这些方格标记为1，即从起始方格 a 到这些方格的距离为1。接着，从活结点队列中取出队首结点作为下一个扩展结点，并将与当前扩展结点相邻且未标记过的方格标记为2，并存入活结点队列。这个过程一直继续到算法搜索到目标方格 b 或活结点队列为空时为止。

代码实现

#define LENGTH 6  // 网格的边长
#define MAX_LENGTH (LENGTH + 2)  // 网格的边长加上边界

int grid[MAX_LENGTH][MAX_LENGTH];  // 网格

typedef struct {  // 网格位置
    int row, col;
} Position;

/**
 * 在给定的起点和终点之间查找路径。
 *
 * @param start 起点位置
 * @param finish 终点位置
 * @param PathLen 路径长度的指针
 * @param path 路径的指针
 * @return 如果找到路径，则返回true；否则返回false。
 */
bool FindPath(Position start, Position finish, int *PathLen, Position **path) {
    Position nextStep[4] = {
        {0, 1},  // 右
        {1, 0},  // 下
        {0, -1}, // 左
        {-1, 0}  // 上
    };

    Position here, next;  // 当前位置和下一个位置
    // 将起点位置赋值给当前位置
    here.row = start.row;  
    here.col = start.col;
    grid[start.row][start.col] = 1;  // 起始点置为1表示已访问
    Queue Q;
    initQueue(&Q);

    while (true) {
        for (int i = 0; i < 4; i++) {  // 检查当前位置的四个方向
            // 四次循环分别检查右、下、左、上四个方向
            next.row = here.row + nextStep[i].row;  
            next.col = here.col + nextStep[i].col;
            // 该位置未被访问过且不是障碍物/边界
            if (grid[next.row][next.col] == 0 && next.row != -1 && next.col != -1) {  
                grid[next.row][next.col] = grid[here.row][here.col] + 1;  // 更新到达该位置的路径长度
                if (next.row == finish.row && next.col == finish.col)   // 到达目标终点
                    break;

                enqueue(&Q, next);  // 将新探测的布线位置(活结点)入队
            }
        }

        if (next.row == finish.row && next.col == finish.col)   // 对于目标终点，不再探测
            break;
        if (isEmpty(&Q)) return false;  // 队列为空，说明没有路径

        here = dequeue(&Q);  // 取出队首元素，作为新的当前位置
    }

    *PathLen = grid[finish.row][finish.col];  // grid终点存储了到达此处的路径长度
    *path = (Position *)malloc(*PathLen * sizeof(Position));  // 分配存储路径轨迹的空间
    here = finish;  // 从终点开始回溯

    for (int j = *PathLen - 1; j >= 0; j--) {  
        (*path)[j] = here;  // 将当前位置存入路径轨迹
        for (int i = 0; i < 4; i++) {  // 检查当前位置的四个方向
            next.row = here.row + nextStep[i].row;  
            next.col = here.col + nextStep[i].col;
            // 回溯时路径长度j逐渐减小，因此若当前位置四周有路径长度为j的点，则说明是上一个点
            if (grid[next.row][next.col] == j)  
                break;
        }
        here = next;  // 将回溯的点作为新的当前位置
    }

    return true;
}

关于 grid 的论述

grid 数组存储了到达当前位置的最短路径长度。

• 为 -1 时，由于不可能存在比它更小的值，因此作为边界/障碍物使用
• 为 0 时，表示尚未记录到达此处的距离，因为表示该点没有被访问过
• 为 >0 的值时，表示到达此处的当前最短距离。

n 后问题

问题定义

在 $n \times n$ 格的棋盘上放置彼此不受攻击的 $n$ 个皇后。按照国际象棋的规则，皇后可以攻击与之处在同一行或同一列或同一斜线上的棋子。$n$ 后问题等价于在 $n \times n$ 格的棋盘上放置 $n$ 个皇后，任何 2 个皇后不放在同一行或同一列或同一斜线上。

算法思想

用 $n$ 元组 $x[1:n]$ 表示 $n$ 后问题的解。其中，$x[i]$ 表示皇后 $i$ 放在第 $i$ 行的第 $x[i]$ 列，则存在以下要求：

• 不在同一行：$i$ 不同就可以保证
• 不在同一列：$x[i]$ 表示第 $x[i]$ 列，因此 $x[i]$ 也互不相同

[!info] 对于不在同一斜线的情况，做出以下论述。

假设 $n \times n$ 格的棋盘的行号从左到右、列号从上到下分别为 $1,2,...,n$，则：

• 斜率为 $-1$ 的直线（有若干条，且互相平行）所对应的格子，例如下图中黄色方格的坐标分别为 $(1,2),\ (2,3)$，其横纵坐标的差值都为 $-1$。同理，红色、黄色对应方格的坐标差值 $0$ 和 $-2$，也是分别相同的。

  因此，假设两个皇后放置的位置分别为 $(i,j),\ (k,l)$，若 $i-j=k-l$，则说明两者同处于斜率为 $-1$ 的斜线上。

• 斜率为 $+1$ 的直线所对应的格子，例如下图中宇宙超级无敌绝绝魅惑紫色方格的坐标分别为 $(2,1),\ (1,2)$，其横纵坐标的和都为 $3$。同理，青色与褐色对应的方格的坐标和也是分别相同的。

  因此，假设两个皇后放置的位置分别为 $(i,j),\ (k,l)$，若 $i+j=k+l$，则说明两者同处于斜率为 $+1$ 的斜线上。

综上所述，我们可以给出 N 后问题的所有约束。

代码实现

[!info] 关于 N 后问题，有一个未按照上述思路优化的原始版本，见仓库代码 NQueen.c

/**
 * 判断在指定位置放置皇后是否可行
 *
 * @param solution 存放皇后位置的数组
 * @param row      当前行数
 * @param col      当前列数
 * @return         如果安全放置皇后，则返回 true；否则返回 false
 */
bool isSafe(int* solution, int row, int col) {
    for (int i = 0; i < row; i++) {
        // 检查是否在同一列或同一斜线上
        if (solution[i] == col || abs(i - row) == abs(solution[i] - col)) {
            return false;
        }
    }
    return true;
}

/**
 * 解决N皇后问题的辅助函数
 * 
 * @param solution 存放皇后位置的数组
 * @param row 当前处理的行
 * @param n 皇后的数量
 */
void solveNQueensUtil(int* solution, int row, int n) {
    if (row == n) {
        // 处理完最后一行，表示找到一个解
        printSolution(solution, n);
        return;
    }

    for (int col = 0; col < n; col++) {  // 遍历当前行的每一列
        if (isSafe(solution, row, col)) {
            // 当前位置安全，将皇后放置在该位置
            solution[row] = col;

            // 递归地尝试放置下一行的皇后
            solveNQueensUtil(solution, row + 1, n);

            // 没有显式地撤销当前皇后的位置，这是因为我们使用了一个一维数组 solution 来存储每行皇后的列位置
            // 回溯：当递归返回到当前行时，我们会继续在其他列尝试放置皇后。在这个过程中，solution[row] 的值会被新的列位置覆盖，这实际上就是撤销了之前放置在该行的皇后。

        }
    }
}

/**
 * 解决N皇后问题
 * 
 * @param n 皇后的数量
 */
void solveNQueens(int n) {
    int* solution = (int*)malloc(n * sizeof(int));  // 申请分配用于存放皇后位置的数组

    solveNQueensUtil(solution, 0, n);  // 从第0行开始处理

    free(solution);  // 释放内存
}

[!question] 为什么 isSafe() 中检查冲突时，只需要检查前 row 行？

在 N 后问题中，我们通常会按行顺序，每一次放置一个皇后。也就是说，当我们在检查是否可以在第 row 行和第 col 列放置皇后时，我们知道所有在第 row 行之前的行已经放置了皇后，而所有在第 row 行之后的行还没有放置皇后。

01 背包问题

问题定义

01 背包问题是背包问题的一个特例，即装入物品时，不能装入物品的一部分，要么全部装入、要么不装入，因为这种非此即彼的选择方式，得名 01 背包问题。

算法思想

在背包问题的解决过程中，我们需要尝试所有可能的物品组合，以找到最优解。为了实现这一点，我们对每个物品都有两种选择：选择它或者不选择它，分别对应解空间的左右子树。当我们选择了一个物品（即 selected[index] = true;）并递归地处理了所有后续的物品后，我们需要撤销对当前物品的选择，以便我们可以在不选择当前物品的情况下，尝试所有可能的后续选择。

但是，当不选择当前物品时，我们可以借助剪枝函数提前回溯：若不选择当前物品 index，则假设尽力装入从下一物品 index+1 开始的剩余物品（按背包问题的方式，即可以装入部分），可以求出一个价值上界。那么：

• 如果这个价值上界小于当前的最高价值，则无需继续考虑从 index+1 开始的该分枝。原因很简单，你 TM 把剩下的破玩意都塞进去也不能达到新的最大价值，那我还装你干什么。
• 反之，如果这个价值上界大于当前的最高价值，那才有考虑该分枝的价值。

代码实现

// 定义物品结构体
typedef struct {
    int id;
    int weight;
    int value;
} Item;

/**
 * 计算选择剩余所有物品后的价值上界
 * 
 * @details 用于剪枝，如果价值上界小于当前最大价值，则不再继续搜索
 * 
 * @param items 物品数组
 * @param n 物品数量
 * @param W 背包容量
 * @param index 当前物品索引
 * @param currentWeight 当前背包重量
 * @param currentValue 当前背包价值
 * @return 价值上界
 */
int upperBound(Item* items, int n, int W, int index, int currentWeight, int currentValue) {
    int remainingWeight = W - currentWeight;  // 剩余容量
    int upperValue = currentValue;  // 上界价值：初始值为当前已选中物品的总价值

    // 从index开始，尽可能多地装入物品
    while (index < n && items[index].weight <= remainingWeight) {  // 不是最后一个物品，且剩余容量足够装下当前物品
        remainingWeight -= items[index].weight;
        upperValue += items[index].value;
        index++;
    }

    if (index < n) {  // 剩余容量不足以装下当前物品
        upperValue += (remainingWeight * (items[index].value/items[index].weight));  // 装入部分当前物品，更新上界价值
    }

    return upperValue;
}

/**
 * 回溯搜索函数
 *
 * @param items 物品数组
 * @param n 物品数量
 * @param W 背包容量
 * @param selected 选中的物品数组
 * @param currentWeight 当前背包重量
 * @param currentValue 当前背包价值
 * @param maxValue 最大背包价值
 * @param index 当前物品索引
 */
void backtrack(Item* items, int n, int W, bool* selected, int* currentWeight, int* currentValue, int* maxValue, int index) {
    if (index == n) {  // 处理完所有物品
        if (*currentWeight <= W && *currentValue > *maxValue) {  // 找到一个更优解
            *maxValue = *currentValue;
            printf("The max value is: %d\n", *maxValue);
            printf("The best choice is as follows:\n");
            for (int i = 0; i < n; i++) {
                if (selected[i]) {
                    printf("item %d\n", items[i].id);
                }
            }
            printf("----------\n");
        }
        return;
    }

    if (*currentWeight + items[index].weight <= W) {  // 当前物品可以装入背包
        selected[index] = true;  // 选中当前物品
        // 更新当前总重量和总价值
        *currentWeight += items[index].weight;
        *currentValue += items[index].value;
        // 选择当前物品的情况下，递归处理下一个物品
        backtrack(items, n, W, selected, currentWeight, currentValue, maxValue, index + 1);

        selected[index] = false;  // 撤销选择当前的物品
        // 恢复不选择这个物品时的总重量和总价值
        *currentWeight -= items[index].weight;
        *currentValue -= items[index].value;
    }
    
    // 不选择当前物品(从index+1开始)的情况下，尝试所有可能的后续选择
    // 如果选择剩余物品的上界价值大于当前最大价值，则递归处理下一个物品
    if (upperBound(items, n, W, index + 1, *currentWeight, *currentValue) > *maxValue) {
        backtrack(items, n, W, selected, currentWeight, currentValue, maxValue, index + 1);  
    }
}

/**
 * 解决01背包问题
 * 
 * @param items 物品数组
 * @param n 物品数量
 * @param W 背包容量
 */
void knapsack(Item* items, int n, int W) {
    // 初始化
    bool selected[n];
    int currentWeight = 0;
    int currentValue = 0;
    int maxValue = 0;
    int index = 0;

    // 按照单位重量价值进行降序排序
    qsort(items, n, sizeof(Item), compare);
    printf("Sort by unitValue:\n");
    for (int i = 0; i < n; i++)
    {
        printf("item %d: weight = %d, value = %d, unitValue = %d\n", items[i].id, items[i].weight, items[i].value, items[i].value/items[i].weight);
    }
    printf("----------\n");
    

    backtrack(items, n, W, selected, &currentWeight, &currentValue, &maxValue, index);

    printf("The final best value is: %d\n", maxValue);
}

基本思想

当一个问题具有最优子结构性质时，可以用动态规划法求解。但有时会有更有效的方法，例如贪心算法。顾名思义，贪心算法总是做出当前看来最好的选择。也就是说贪心算法并不从整体最优上加以考虑，它所做出的选择只是在某种意义上的局部最优选择。当然，我们希望贪心算法得到的最终结果也是整体最优的。

虽然贪心算法不是对所有问题都能得到整体最优解，但对范围相当广的许多问题它能产生整体最优解。如图的单源最短路径问题、最小生成树问题等。在一些情况下，即使贪心算法不能得到整体最优解，但其最终结果却是最优解的很好的近似解。

活动安排问题

问题定义

设有 $n$ 个活动的集合 $E={1,2,...,n}$，其中每个活动都要求使用同一资源，如演讲会场等，而在同一时间内只有一个活动能使用这一资源。每个活动 i 都有一个要求使用该资源的起始时间 $s_i$ 和一个结束时间 $f_i$，且 $s_i \lt f_i$。如果选择了活动 $i$，则它在半开时间区间 $[s_i\ f_i)$ 内占用资源。若区间 $[s_i,\ f_i)$ 与区间 $[s_j,\ f_j)$ 不相交，则称活动 $i$ 与活动 $j$ 是相容的。也就是说，当 $s_i \geq f_j$ 或 $s_j \geq f_i$ 时，活动 $i$ 与活动 $j$ 相容。活动安排问题就是要在所给的活动集合中选出最大的相容活动子集合。

算法思想

首先对活动按照结束时间进行排序。然后，我们选择第一个活动，并从第二个活动开始遍历，如果当前活动的开始时间大于等于前一个所选活动的结束时间，则选择该活动，并输出其信息。

由于算法每次总是选择具有最早完成时间的相容活动。直观上，按这种方法选择相容活动为未安排活动留下尽可能多的时间。也就是说，该算法的贪心选择的意义是使剩余的可安排时间段极大化，以便安排尽可能多的相容活动。

代码实现

// 活动结构体
typedef struct {
    int start;
    int finish;
} Activity;

// 比较函数，用于排序活动
int compare(const void* a, const void* b) {
    // 类型转换的优先级低，因此需要加两重括号
    return ((Activity*)a)->finish - ((Activity*)b)->finish;
}

// 贪心算法解决活动安排问题
void activityScheduling(Activity activities[], int n) {

    // 按照结束时间对活动进行排序
    qsort(activities, n, sizeof(Activity), compare);

    // 输出排序后的activities数组
    printf("Sorted activities, format is 'id: (start time, end time)': \n");
    for (int i = 0; i < n; i++) {
        printf("%d: (%d, %d)\n", i + 1, activities[i].start, activities[i].finish);
    }

    printf("selected activity, format is 'id: (start time, end time)': \n");

    // 选择第一个活动
    int i = 0;
    printf("%d: (%d, %d)\n", i + 1, activities[i].start, activities[i].finish);

    // 选择其他活动
    for (int j = 1; j < n; j++) {
        if (activities[j].start >= activities[i].finish) {  // 活动j与活动i不冲突
            i = j;  // 选择活动j
            printf("%d: (%d, %d)\n", i + 1, activities[i].start, activities[i].finish);
        }
    }
}

全局最优解证明

贪心算法并不总能求得问题的整体最优解。但对于活动安排问题，贪心算法却总能求得的整体最优解。这个结论可以用数学归纳法证明。

假设活动集合 $E={1,2,...,n}$ 是一个已经以结束时间非递减顺序排好的集合，那么活动 1 的完成时间是最早的。

首先证明存在第一个活动就是贪心算法选择的活动的最优解。假设 $A \subseteq E$ 是一个最优解，且 $A$ 中的活动也是以结束时间非递减顺序排好的。假设 $A$ 中的第一个活动是 $k$：

• 当 $k=1$ 时，最优解的第一个活动就是贪心选择的活动。
• 当 $k \geq 1$ 时，假设 $B=A-{k}\ \cup {1}$ ，则 $B$ 也是相容的，并且个数与 $A$ 相同，所以 $B$ 也是最优的，且也是以贪心选择活动 1 开始的。

{% note info modern %} $B=A-{k}\ \cup {1}$ 就是从 $A$ 中把第一个活动从 $k$ 替换为 1。显然，1 作为结束时间最早的活动，你一个结束的不比我早的 $k$ 放进去都相容，那换成 1 必定也相容。 {% endnote %}

综上，总是存在以贪心选择开始的最优解。

在选择了活动 1 后，剩下的任务就是从 $E' = E-{1}$ 中继续选择活动。若 $A$ 是最优解，则 $A'=A-{1}$ 也是 $E'$ 的最优解。下面给出证明。

假设能找到 $E'$ 的另一个最优解 $B'$，其包含的活动数量比 $A'$ 更多，那就八达鸟了。如果说最优解 $A$ 里包含 $m$ 个活动，那么 $A'$ 比它少一个，也就是 $m-1$ 个。那作为比 $A'$ 数量更多的 $B'$，至少得是 $m$ 个吧，并且这 $m$ 个活动里不包括活动 1（因为活动 1 已经被选择了，all right？）。还是那个道理，活动 1 作为结束最早的活动，把它加入 $B'$ 显然也是相容的，此时 $B'$ 至少包含 $m+1$ 个活动。显然，最优解也才 $m$ 个，那 $B'$ 直接荣登最优解，这与假设矛盾。

综上，在活动安排问题中，贪心算法得出的解就是全局最优解。

背包问题

问题定义

给定 $n$ 种物品和一个背包。物品 $i$ 的重量是 $w_i$，其价值为 $v_i$，背包的容量为 $c$。假设装入物品时，可以选择物品 $i$ 的一部分，那么如何选择装入背包中的物品，使得装入背包中的物品总价值最大？

算法思想

首先计算每种物品单位重量的价值 $\frac {v_i} {w_i}$，然后依据贪心策略，将尽可能多的单位价值最高的物品装入背包。若装入后总重量未超过背包容量 $c$，则继续装入单位重量次高的物品，以此类推，直到背包装满为止。

{% note warning modern %} 与 01 背包区分，背包问题（分数背包问题）由于可以装入物品的一部分，因此是可以全部装满的。 {% endnote %}

代码实现

struct Item {
    int weight;
    int value;
    char *name;  // 物品名称
};

/**
 * 贪心算法解决背包问题
 *
 * @param capacity 背包的容量
 * @param items 物品数组
 * @param numItems 物品的数量
 */
void knapsackGreedy(int capacity, struct Item items[], int numItems) {
    qsort(items, numItems, sizeof(struct Item), compare);  // 按照单位价值从大到小排序

    double totalValue = 0.0;  // 背包中物品的总价值
    int currentWeight = 0;  // 背包中物品的总重量
    int i;

    for (i = 0; i < numItems; i++) {
        if (currentWeight + items[i].weight <= capacity) {  // 物品可以全部装入背包
            totalValue += items[i].value;
            currentWeight += items[i].weight;
            printf("selected all: %s, weight: %d, value: %d\n", items[i].name, items[i].weight, items[i].value);
        } else {  // 物品只能部分装入背包
            int remain = capacity - currentWeight;
            totalValue += items[i].value * ((double)remain / items[i].weight);
            printf("selected part: %s, weight: %d, value: %.2f\n", items[i].name, remain, items[i].value * ((double)remain / items[i].weight));
            break;  // 背包已经装满，退出循环
        }
    }

    printf("max value is: %f\n", totalValue);
}

基本思想

与分治法类似，其基本思想也是将待求解问题分解成若干个子问题，先求解子问题，然后从这些子问题的解得到原问题的解。

与分治法不同的是，适合于用动态规划法求解的问题，经分解得到的子问题往往不是互相独立的，有些子问题被重复计算了许多次。如果我们能够保存已解决的子问题的答案，而在需要时再找出已求得的答案，这样就可以避免大量的重复计算，从而得到多项式时间算法。

为了达到此目的，可以用一个表来记录所有已解决的子问题的答案。不管该子问题以后是否被用到，只要它被计算过，就将其结果填入表中。这就是动态规划法的基本思想。

矩阵连乘问题

问题定义

矩阵连乘算法问题是一个经典的优化问题，其目标是找到一种最优的计算顺序，以最小化矩阵连乘操作的总次数。

假设有一系列矩阵 $A_1, A_2, A_3, ..., A_n$ ，其中矩阵 $A_i$ 的维度为 $p_{i-1} \times p_i$ ，我们想要计算它们的连乘积 $A_1 \cdot A_2 \cdot A_3 \cdot ... \cdot A_n$ 。注意，矩阵连乘是一个不可交换的操作，即矩阵的乘法顺序会影响最终结果。

矩阵连乘问题的目标是找到一种最优的计算顺序，使得计算矩阵连乘的总次数最小。这个问题可以使用动态规划的方法来解决，其中关键是定义一个递归的状态和状态转移方程。

分析最优子结构

将矩阵连乘积 $A_iA_{i+1}...A_j$ 记为 $A[i:j]$ 。假设最优计算次序是在 $A_k$ 和 $A_{k+1}$ 之间断开，则原问题的解即为 $A[1:k]$ 的计算量加上 $A[k+1:n]$ 的计算量再加上 $A[1: k]\cdot A[k+1:n]$ 的计算量。

那么这个拆解过程存在一个前提，就是计算 $A[1:n]$ 的最优次序所包含的矩阵子链 $A[1:k]$ 和 $A[k+1:n]$ 的次序也是最优的。我们可以用反证法来证明这一点是成立的。

假设当 $A[1:k], A[k+1:n]$ 这种计算次序最优时， $A[1:k]$ 的计算次序不是最优的，即存在 $k'$ ，使得 $A[1:k']$ 的计算量小于 $A[1:k]$ 。那么显然， $A[1: k'], A[k'+1:n]$ 这种拆解方式的计算量一定小于原先的 $A[1:k]$ 和 $A[k+1:n]$ ，即 $A[1:k], A[k+1:n]$ 的计算次序不是最优，这与假设矛盾。

{% note info modern %} 同理可证 $A[1: n]$ 所包含的矩阵子链 $A[k+1:n]$ 也是最优的。 {% endnote %}

综上，矩阵连乘问题的最优解包含着其子问题的最优解，这种性质称为最优子结构性质。

{% note warning modern %} 问题的最优子结构性质是该问题可用动态规划算法求解的显著特征。 {% endnote %}

算法思想

在确定了原问题具有最优子结构性质后，我们需要递归地定义最优值。假设计算 $A[i:j]$ 所需的最少数乘次数为 $m[i][j]$ ，则原问题 $A[1:n]$ 的最优值为 $m[1][n]$ 。

• 当 $i=j$ 时， $A[i:j]$ 就是一个单独的矩阵，所以 $m[i][j]=0$
• 当 $i \lt j$ 时， $m[i][j]=m[i][k]+m[k+1][j]+p_{i-1}p_kp_j$

{% note info modern %} $i<j$ 时的解释 关于 $p$ ，我们将矩阵 $A_i$ 的维数记为 $p_{i-1} \times pi$ 。此处有一个问题，就是对于两个矩阵相乘，总共的数乘次数为多少？若 $A$ 是 $p \times q$ 矩阵， $B$ 是 $q\times r$ 矩阵，则计算 $AB$ 总共需要 $pqr$ 次数乘。

p 行，每行都要乘 r 列，一共就是 pr 次乘法。每一次乘法都是 q 个数和 q 个数相乘，因此总共为 prq=pqr 次。

因此， $m[i][k]$ 表示从 $A_i$ 乘到 $A_k$ ，其中 $A_i$ 是 $(i-1) \times i$ 矩阵， $A_k$ 是 $(k-1) \times k$ 矩阵，由于矩阵连乘的前提一定是矩阵链是可乘的，因此 $A[i:k]$ 的结果是一个 $(i-1) \times k$ 矩阵。同理， $A[k+1:j]$ 的结果是 $k \times j$ 矩阵。所以这两个矩阵相乘的数乘次数为 $p_{i-1}p_kp_j$ 。 {% endnote %}

那么 $k$ 取多少呢？我们无法确定，因为 $i \leq k \lt j$ 的位置有 $i,i+1,...,j-1$ 共 $j-i$ 种可能，因此 $m[i][j]$ 递归地定义为：

$$ m[i][j] = \begin{cases} 0 & i=j \ \min\limits_{i \leq k \lt j}{m[i][j]=m[i][k]+m[k+1][j]+p_{i-1}p_kp_j} & i \lt j \end{cases} $$

上式给出了两个信息，一是最优值 $m$ ，即矩阵连乘所需的最小次数；二是最优解 $k$ ，即应该怎么划分才能获得最优值。

代码实现

/**
 * 使用动态规划解决矩阵连乘问题，并返回最小计算次数和最优解
 * 
 * @param dimensions 矩阵的维度数组
 * @param n 矩阵的数量
 * @param dp 存储最小计算次数的二维数组
 * @param split 存储最优划分点的二维数组
 * @return 最小计算次数
 */
int matrixChainOrder(int dimensions[], int n, int dp[MAX_MATRICES][MAX_MATRICES], int split[MAX_MATRICES][MAX_MATRICES]) {
    // 初始化dp数组和split数组
    for (int i = 1; i <= n; i++) {
        dp[i][i] = 0;
    }

    // 计算子问题的最优解和划分点
    for (int len = 2; len <= n; len++) {  // 子问题规模
        for (int i = 1; i <= n - len + 1; i++) {  // 子问题的起始位置
            int j = i + len - 1;  // 子问题的结束位置
            dp[i][j] = INT_MAX;  // 初始化最优值为最大值

            for (int k = i; k < j; k++) {  // 子问题的划分点
                int cost = dp[i][k] + dp[k + 1][j] + dimensions[i - 1] * dimensions[k] * dimensions[j];
                if (cost < dp[i][j]) {  
                    dp[i][j] = cost;  // 更新最优值
                    split[i][j] = k; // 记录最优划分点
                }
            }
        }
    }

    // 返回最小计算次数
    return dp[1][n];
}


/**
 * 输出最优解
 * 
 * @param split 分割矩阵的位置
 * @param i 矩阵的起始位置
 * @param j 矩阵的结束位置
 */
void printOptimalParenthesis(int split[MAX_MATRICES][MAX_MATRICES], int i, int j) {
    if (i == j) {  // 矩阵只有一个时，直接输出
        printf("A%d", i);
    } else {  // 矩阵有多个时，递归输出
        printf("(");  // 输出左括号
        printOptimalParenthesis(split, i, split[i][j]);  // 输出左边的矩阵链的
        printOptimalParenthesis(split, split[i][j] + 1, j);  // 输出右边的矩阵链
        printf(")");  // 输出右括号
    }
}

在这段代码中，三重循环的循环变量分别代表以下内容：

1. 外层循环变量 len：表示子问题的规模，从2开始逐渐增加，直到达到矩阵的大小 n。这个循环用于控制子问题的规模。
2. 中间循环变量 i：表示子问题的起始位置，从1开始逐渐增加，直到 n - len + 1。这个循环用于遍历所有可能的子问题起始位置。
3. 内层循环变量 k：表示子问题的划分点，从 i 开始逐渐增加，直到 j。这个循环用于遍历所有可能的划分点，计算出最优的划分点。

{% note info modern %} 关于 len {% endnote %}

循环从 len = 2 开始，是因为在矩阵乘法中，我们需要先计算较小的子矩阵的乘积，然后逐渐增加子矩阵的大小。通过从较小的子矩阵开始，我们可以利用已经计算出的乘积结果来计算更大的子矩阵的乘积。

例如，对于一个 4x4 的矩阵，我们首先计算 2x2 的子矩阵的乘积，然后计算 3x3 的子矩阵的乘积，最后计算整个 4x4 矩阵的乘积。通过从较小的子矩阵开始，我们可以利用已经计算出的 2x2 子矩阵的乘积来计算 3x3 子矩阵的乘积，从而减少计算量。

因此，循环从 len = 2 开始，以便从较小的子矩阵开始计算乘积，并逐渐增加子矩阵的大小，直到计算整个矩阵的乘积。

{% note warning modern %} 为什么 $i \leq n-len+1$ ？ {% endnote %}

假设矩阵下标从 1 开始到 n。当问题规模为 len 时，即 $[1:len],\ [2:len+1], ...$ 这样逐个划分计算，其对应的起始位置就是 $1,2,...$ 。那么，我们要求起始位置的上界，对应的极端情况显然是长度为 len 的矩阵链在整个矩阵连乘的式子中尽可能地靠右，这样得到的起始位置就是尽可能大的。

所以问题就变成了，已知最后（最右的）一个矩阵为 n，从它开始向左推一个长度为 len 的矩阵链，这个链的起始位置是谁? 显然，答案是 $n-len+1$ 。

{% note warning modern %} 矩阵的维度有两个值，为什么可以通过一维数组 dimensions 来表示？ {% endnote %}

参见上文两矩阵的数乘次数问题，我们可知，对于第 i 个矩阵， dimensions[i-1] 是它的行数， dimensions[i] 是它的列数。这是因为，如果我们按照顺序进行矩阵链乘法，那么第 i 个矩阵的列数必须等于第 i+1 个矩阵的行数（矩阵可乘，左列等于右行），所以我们可以用一个连续的数组来存储所有矩阵的行数和列数。

最长公共子序列

问题定义

给定两个序列 $X={x_1, x_2,..., x_m},, Y={y_1, y_2, ..., y_n}$ ，找出最长的、公共的子序列。

分析最优子结构

最长公共子序列问题有没有最优子结构性质，说白了就是，如果有最长公共子序列 $Z_k={z_1,z_2,...,z_k}$ ， $Z_{k-1}$ 是不是第二长的？（当然是的）下面给出该问题的最优子结构性质定义：

设序列 $X_m={x_1, x_2,..., x_m},, Y_n={y_1, y_2, ..., y_n}$ 的最长公共子序列为 $Z_k={z_1,z_2,...,z_k}$ ，则

• 若 $x_m=y_n$ ，则 $z_k=x_m=y_n$ ，且 $Z_{k-1}$ 是 $X_{m-1}$ 和 $Y_{n-1}$ 的最长公共子序列
• 若 $x_m\neq y_n$ 且 $z_k\neq x_m$ ，则 $Z_k$ 是 $X_{m-1}$ 和 $Y$ 的最长公共子序列
• 若 $x_m\neq y_n$ 且 $z_k\neq y_n$ ，则 $Z_k$ 是 $X$ 和 $Y_{n-1}$ 的最长公共子序列

{% note info modern %} 下面分别针对这三点给出证明 {% endnote %}

若 $x_m=y_n$ 时，$z_k\neq x_m$，那意味着最长公共子序列 $Z_k$ 不是最长的。因为 ${z_1,z_2,...z_k,x_m}$ 显然也是公共子序列，且长度为 $k+1$，比 $Z_k$ 还长，构成矛盾。所以当 $x_m=y_n$ 时，必有 $z_k=x_m=y_n$，同时 $Z_{k-1}$ 是 $X_{m-1}$ 和 $Y_{n-1}$ 的公共子序列。

接下来证明 $Z_{k-1}$ 是最长的。假设 $X_{m-1}$ 和 $Y_{n-1}$ 有长度 $\gt k-1$ 的公共子序列 $W$，那就八达鸟了。因为 $W$ 的长度至少是 $k$，再把两个父串共有的 $x_m$ 加上，$W$ 的长度直接达到 $k+1$，此之谓无中生有，故矛盾。

若 $x_m\neq y_n$ 且 $z_k\neq x_m$ ，则 $Z_k$ 肯定是 $X_{m-1}$ 和 $Y$ 的公共子序列，不过是不是最长的呢？还是反证法，我们假设 $X_{m-1}$ 和 $Y$ 有长度大于 $k$ 的公共子序列 $W$，显然 $W$ 也是 $X$ 和 $Y$ 的公共子序列。但 $X$ 和 $Y$ 的最长公共子序列为 $Z_k={z_1,z_2,...,z_k}$ 长度也只有 $k$，故矛盾。

第三点证明与二同理，略。

综上，最长公共子序列问题具有最优子结构性质。

算法思想

根据最优子结构性质可知，

• 任一串为空时，最长公共子序列长度为 0
• 当 $x_m=y_n$ 时，找出 $X_{m-1}$ 和 $Y_{n-1}$ 的最长公共子序列，然后尾部加上 $x_m\ \text{or}\ y_n$ 即为 $X$ 和 $Y$ 的最长公共子序列。
• 当 $x_m\neq y_n$ 时，取 $X_{m-1}$ 和 $Y$、$X$ 和 $Y_{n-1}$ 的最长公共子序列中更长的一个

将序列 $X_i$ 和 $Y_j$ 的最长公共子序列长度记为 $c[i][j]$，根据以上内容，构建递推关系式如下：

$$ c[i][j] = \begin{cases} 0 & i=0\ \text{or}\ j=0 \ c[i-1][j-1] + 1 & i,j \gt 0;\ x_i = y_j \ \max{c[i][j-1],c[i-1][j]} & i,j \gt 0;\ x_i \neq y_j \end{cases} $$

代码实现

/**
 * 使用动态规划解决最长公共子序列问题
 * 
 * @param str1 字符串1
 * @param str2 字符串2
 */
void longestCommonSubsequence(char* str1, char* str2) {
    int m = strlen(str1);
    int n = strlen(str2);

    int dp[m + 1][n + 1];

    // 初始化dp数组的第一行和第一列
    for (int i = 0; i <= m; i++) {  
        dp[i][0] = 0;  
    }
    for (int j = 0; j <= n; j++) {
        dp[0][j] = 0;
    }

    // 计算dp数组的其他元素
    for (int i = 1; i <= m; i++) {
        for (int j = 1; j <= n; j++) {
            if (str1[i - 1] == str2[j - 1]) {  // 两个子串的最后一个字符相同
                dp[i][j] = dp[i - 1][j - 1] + 1;
            } else {
                dp[i][j] = (dp[i - 1][j] > dp[i][j - 1]) ? dp[i - 1][j] : dp[i][j - 1];
            }
        }
    }

    // 构造最长公共子序列
    int lcsLength = dp[m][n];
    char lcs[lcsLength + 1];
    lcs[lcsLength] = '\0';

    int i = m, j = n;
    while (i > 0 && j > 0) {
        // 串的扫描和LCS的构建都是从右往左，倒着来
        if (str1[i - 1] == str2[j - 1]) {  // 两个串的尾部字符相等，说明该字符属于LCS
            lcs[lcsLength - 1] = str1[i - 1];
            i--;
            j--;
            lcsLength--;
        } else if (dp[i - 1][j] > dp[i][j - 1]) {  // 删去str1最后一个字符得到的LCS比删去str2最后一个字符得到的LCS长，因此i向前回溯
            i--;
        } else {
            j--;
        }
    }
    printf("LAS Length is: %d\n", dp[m][n]);
    printf("LCS is: %s\n", lcs);  // 注意，最长公共子序列并不唯一
}

基本思想

将一个规模为 n 的问题，分解为 k 个规模较小的子问题。这些子问题相互独立且与原问题相同。递归求解这些子问题，然后将各子问题的解合并得到原问题的解。

二分搜索

算法思想

算法的核心思想是通过不断缩小搜索范围来逼近目标元素。在每一次迭代中，算法首先计算出中间元素的索引 mid ，然后将其与目标元素进行比较。

• 如果中间元素等于目标元素，则直接返回中间元素的索引
• 如果中间元素小于目标元素，则将搜索范围缩小为右半部分，将左边界更新为 mid + 1
• 如果中间元素大于目标元素，则将搜索范围缩小为左半部分，将右边界更新为 mid - 1 通过不断缩小搜索范围，最终可以找到目标元素或确定其不存在于数组中。

请注意，二分搜索假设输入的数组已经按升序排列。如果数组未排序，需要在进行二分搜索之前先对数组进行排序。

代码实现

/**
 * 二分查找算法
 * 在有序数组中查找目标元素的索引
 * 
 * @param nums 有序数组
 * @param size 数组大小
 * @param target 目标元素
 * @return 目标元素的索引，如果不存在则返回-1
 */
int binarySearch(int nums[], int size, int target) {
    
    int left = 0; // 左边界
    int right = size - 1; // 右边界

    while (left <= right) {
        // 因为是升序，所以可以保证 right>=left
        int mid = left + (right - left) / 2;

        if (nums[mid] == target) {
            return mid;
        } else if (nums[mid] < target) {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }

    return -1; // 如果目标元素不存在于数组中，则返回-1
}

复杂度分析

每执行一次 while 循环，待搜索数组的大小减少一半。因此最坏情况下，时间复杂度为 $O(log_n)$

Q&A

[!question] 为什么别的算法书是 mid = (left + right) / 2; ？

这是因为在计算中间索引时，使用 (right - left) / 2 可以避免整数溢出的问题。

假设 left 和 right 都是很大的正整数，它们的和可能会超过 int 类型的最大值。如果我们使用 (right + left) / 2 来计算中间索引，可能会导致溢出错误。通过使用 (right - left) / 2 ，我们可以确保在计算中间索引时不会发生溢出。

棋盘覆盖

问题定义

假设你有一个 $2^n \times 2^n$ 大小的棋盘，其中一个方格已经被预先填充（或者说被“覆盖”）。你的任务是使用 L 型的三个方格形状的骨牌（也就是说，它覆盖了一个 2x2 的方格，但是缺少了一个角落）来覆盖剩余的所有方格，且任何 2 个 L 型骨牌不得重叠覆盖，如此使得整个棋盘都被填满。

算法思想

这个问题可以通过分治算法来解决。基本的思路是将棋盘分成四个更小的棋盘，每个棋盘的大小是原来的一半（指边长为 2 的正方形），则特殊方格必定位于 4 个较小的子棋盘之一。

为了将无特殊方格的子棋盘转化为特殊棋盘，可以用一个 L 型的骨牌覆盖这三个较小棋盘的交汇处。

然后，对每个更小的棋盘递归地应用同样的过程，直到达到基本情况，即棋盘的大小为 $1\times1$ 。

代码实现

/**
 * 在棋盘上放置覆盖物
 * 
 * @param tr 当前棋盘的左上角行坐标(row)
 * @param tc 当前棋盘的左上角列坐标(column)
 * @param dr 特殊方格行坐标
 * @param dc 特殊方格列坐标
 * @param size 当前棋盘的大小
 */
void chessboard(int tr, int tc, int dr, int dc, int size) {
    if (size == 1) {
        return;
    }

    int t = tile++; // L型骨牌编号, 自增确保编号唯一
    int s = size / 2; // 分割后棋盘大小

    // 处理左上角子棋盘
    if (dr < tr + s && dc < tc + s) {  // 特殊方格在此棋盘中, 直接递归处理
        chessboard(tr, tc, dr, dc, s); 
    } else {  // 特殊方格不在此棋盘中, 先覆盖再处理
        board[tr + s - 1][tc + s - 1] = t; // 用t号L型骨牌覆盖右下角方格
        chessboard(tr, tc, tr + s - 1, tc + s - 1, s); // 处理其余方格
    }

    // 处理右上角子棋盘
    if (dr < tr + s && dc >= tc + s) {
        chessboard(tr, tc + s, dr, dc, s);
    } else {
        board[tr + s - 1][tc + s] = t; // 覆盖左下角
        chessboard(tr, tc + s, tr + s - 1, tc + s, s);
    }

    // 处理左下角子棋盘
    if (dr >= tr + s && dc < tc + s) {
        chessboard(tr + s, tc, dr, dc, s);
    } else {
        board[tr + s][tc + s - 1] = t; // 覆盖右上角
        chessboard(tr + s, tc, tr + s, tc + s - 1, s);
    }

    // 处理右下角子棋盘
    if (dr >= tr + s && dc >= tc + s) {
        chessboard(tr + s, tc + s, dr, dc, s);
    } else {
        board[tr + s][tc + s] = t; // 覆盖左上角
        chessboard(tr + s, tc + s, tr + s, tc + s, s);
    }
}

请注意，这段代码中假设棋盘的大小为 $8\times8$ ，并且特殊位置的行号和列号为 0。你可以根据需要修改这些值。另外，代码中使用 #define 定义了一些常量，你也可以根据需要进行修改。

最终结果如下：

切换到 conda 环境下，执行

pip install labelimg

{% note info modern %} 如果下载缓慢，请切换清华源，见 pypi | 镜像站使用帮助 | 清华大学开源软件镜像站 | Tsinghua Open Source Mirror {% endnote %}

{% note warning modern %} Python 环境最多只能为 3.9，Labelimg 不支持 3.10 以上版本 {% endnote %}

数据准备

首先这里需要准备我们需要打标注的数据集。这里我建议新建一个名为 img_data 的文件夹（这个是约定俗成，不这么做也行），里面创建一个名为 images 的文件夹存放我们需要打标签的图片文件；再创建一个名为 labels 存放标注的标签文件；最后创建一个名为 classes.txt 的 txt 文件来存放所要标注的类别名称。

然后把要标注的图片放在 images/ 下

在 classes.txt 中写入所有用到的标签

标注

启动 labelimg

从你的 conda prompt 进入数据集路径

不然你找不到 Labelimg 这个东西

执行

labelimg images classes.txt

拿下！

开始标注

标注过程：

1. 选中左侧 create rectbox
2. 框选图片中主体
3. 选择图片标签（该标签来自于 classes.txt ）

保存标注

点击 save 下方的按钮可以切换保存的模式，此处切换为 YOLO 。不同的模型所需的标签格式不同，例如 YOLO 所需的标签类型即为 txt 。

点击 save ，将 image_name.txt 保存在刚刚创建的 img_data\labels 路径下。

{% note info modern %} 例如对一张名为 aaa.jpg 的图片进行了标注，则生成的对应标签为 aaa.txt （YOLO 模式下） {% endnote %}

无法加载文件，因为在此系统上禁止运行脚本

get-executionpolicy  # 获取当前执行策略
set-executionpolicy remotesigned  # 设置执行策略

[!info] 执行策略 Restricted 执行策略 (默认设置) 不允许任何脚本运行。   AllSigned 和 RemoteSigned 执行策略可防止 Windows PowerShell 运行没有数字签名的脚本。

高级特性

不清楚具体是哪个版本开始，power shell 具有了自动补全的功能，我还以为是 starship 带来的呢 hhhh

在输入重复指令时，可以看见提示信息以灰色字体出现在当前光标后方，按右箭头键即可自动补全。

按下 F2，可以查看不同完成建议的列表，通过上下箭头选中，回车上屏。

按照 reddit 的说法，该功能是巨硬合并了 PSReadline 模块后带来的。

概念

PowerShell 命令称为 cmdlet（读作 command-let）。除了 cmdlet 外，使用 PowerShell 还可以在系统上运行任何可用命令。

PowerShell 使用 “动词 - 名词” 名称对来命名 cmdlet。例如，PowerShell 中包含的 Get-Command cmdlet 用于获取在命令行界面中注册的所有 cmdlet。谓词标识 cmdlet 执行的操作，名词标识该 cmdlet 执行其操作的所在资源。

谓词

谓词是 PowerShell 中的一个重要概念。它是大多数 cmdlet 都遵循的一种命名标准。你在编写自己的命令时，也应遵循此命名标准。其中的思路是，谓词表示你尝试执行的操作，例如读取数据或更改数据。 PowerShell 有一个标准化的谓词列表。要获取所有可用谓词的完整列表，请使用 Get-Verb cmdlet：

PS F:\> get-verb

Verb      AliasPrefix     Group        Description
----        -----------      -----          -----------
......
......

环境变量的用法

不同于 Linux 的直接使用 $key，powershell 中必须加上 $env: 的前缀

$env:your_env

Get-Member 发现对象、属性和方法

# 获取当前路径下所有vtt字幕文件
$vtts = Get-ChildItem -Path . -Filter "*.vtt"
# 取出其中一个
$vtt = $vtts[0]
# 查看其具有的对象、属性和方法
$vtt | Get-Member
# 只想查看其属性
$vtt | Get-Member -MemberType Properties

Get-Command 查找命令

Get-Command cmdlet 将返回系统上安装的所有可用命令的列表，包含四个属性字段

根据名称筛选

#  查找名为Get-Process的命令
Get-Command -Name Get-Process

# 使用通配符进行模糊查询：查找所有名为 "xxx-Process" 的命令
Get-Command -Name *-Process

根据名词和谓词进行筛选

# 根据谓词筛选：查找名为 "Get-xxx" 的命令
Get-Command -Verb 'Get'

# 根据名词筛选：查找名为 "xxx-Uxxx" 的命令
Get-Command -Noun U*

# 也可以组合参数缩小搜索范围
Get-Command -Verb Get -Noun U*

使用其他 Cmdlet 筛选结果

Select-Object 此通用命令可帮助你从一个或多个对象中选取特定属性。还可以限制返回的项目数。

# 返回当前会话中前 5 个可用命令的 Name 和 Source 属性值
Get-Command | Select-Object -First 5 -Property Name, Source

文件 IO

创建文本文件

# 创建
New-Item .\shell_test\text.txt
# 写入
Set-Content .\shell_test\text.txt 'this is a text written by powershell.'
# 读取
Get-Content .\shell_test\text.txt

清空文件内容

Clear-Content .\shell_test\text.txt

插入文件内容

Set-Content .\shell_test\text.txt 'hello'
Add-Content .\shell_test\text.txt 'world'
Get-Content .\shell_test\text.txt

结果为

hello
world

看起来是会自动写入换行符

文件和文件夹

New-Item cmdlet 用于通过使用 -Path 作为文件路径和 -ItemType 作为文件传递路径来创建文件。

创建

创建文件夹：在 F:\ 下创建 shell_test 文件夹

New-Item -Path 'F:\shell_test' -ItemType Directory

创建文件：在 F:\shell_test 下创建 test.txt 文件

New-Item -Path 'F:\shell_test\test.txt' -ItemType File

复制

Copy-Item cmdlet 用于通过传递要复制的目录/文件的路径和目标路径来复制目录。

复制文件夹

Copy-Item 'F:\shell_test\' 'F:\copy_shell_test'

递归复制文件夹（包含里面的内容）

Copy-Item 'F:\shell_test\' -Recurse 'F:\copy_shell_test'

复制指定的内容

Copy-Item -Filter *.jpg -Path 'F:\shell_test\' -Recurse 'F:\copy_shell_test'

删除

Remove-Item cmdlet 用于通过传递要删除的目录/文件的路径来删除。

# 删除文件
Remove-Item 'F:\shell_test\aa.jpg'
# 删除文件夹
Remove-Item 'F:\shell_test'

当删除文件夹不为空时，会提示

Confirm
The item at F:\shell_test has children and the Recurse parameter was not specified. If you continue, all children will
be removed with the item. Are you sure you want to continue?
[Y] Yes  [A] Yes to All  [N] No  [L] No to All  [S] Suspend  [?] Help (default is "Y"):

因此，可以递归删除文件夹

# 删除 shell_test 及其目录下所有内容
Remove-Item 'F:\shell_test' -Recurse
# 效果同上
Remove-Item 'F:\shell_test\' -Recurse
# 删除 shell_test 目录下所有内容，但不会删除 shell_test 本身
Remove-Item 'F:\shell_test\*' -Recurse

移动

Move-Item cmdlet 用于通过传递要移动的目录/文件的路径和目标路径来移动目录。

# 移动单个文件
Move-Item 'F:\shell_test\2' [-Destination] F:\shell_test\1

# 移动多个文件
Move-Item file1,file2 -Destination /path/to/target

注意两个问题：

1. 不涉及复杂参数的情况下，路径参数的引号可以不加
2. F:\shell_test\2 路径下的文件也会被移动
3. 移动多个文件时，如果省略 -Destination，则最后一个路径默认作为目的地
4. 移动命令没有 -Recurse 一说
5. -Force 参数可以强制运行命令而不要求用户确认。

重命名

Rename-Item cmdlet 用于通过传递要重命名的文件 (夹) 的路径和目标名称来重命名文件 (夹)。

# 将 1 重命名为 this1
Rename-Item 'F:\shell_test\1' this1

需注意，同路径下不可以有同名文件夹，否则会失败。

检测是否存在

Test-Path cmdlet 用于检查文件 (夹) 是否存在。

Test-Path 'F:\shell_test\'

结果为

1
2
3
4
5
8

Measure-Object

Measure-Object cmdlet 可用于获取传递的输出的属性，例如最小值、最大值、大小、计数、行等。

# 获取文件属性
Get-Content .\shell_test\text.txt | Measure-Object -line -word -Character

结果为（行数、单词数、字符数）

Lines Words Characters Property
----- ----- ---------- --------
2       2         10

统计目录下文件数量

Get-ChildItem .\shell_test\ | Measure-Object

表示共有 3 个文件（文件 + 文件夹）

Count             : 3
Average           :
Sum               :
Maximum           :
Minimum           :
StandardDeviation :
Property          :

也可以如下操作：

$zips = Get-ChildItem *.zip
$zips.Count  # 也能直接获取数量

比较运算符

https://learn.microsoft.com/zh-cn/powershell/module/microsoft.powershell.core/about/about_comparison_operators?view=powershell-7.4

等式

• -eq、-ieq、-ceq - 等于
• -ne、-ine、-cne - 不等于
• -gt、-igt、-cgt - 大于
• -ge、-ige、-cge - 大于或等于
• -lt、-ilt、-clt - 小于
• -le、-ile、-cle - 小于或等于

匹配

• -like、-ilike、-clike - 字符串匹配通配符模式
• -notlike、-inotlike、-cnotlike - 字符串与通配符模式不匹配
• -match、-imatch、-cmatch - 字符串匹配正则表达式模式
• -notmatch、-inotmatch、-cnotmatch - 字符串与正则表达式模式不匹配

替代功能

• -replace，-ireplace，-creplace - 替换与正则表达式模式匹配的字符串

包含

• -contains、-icontains、-ccontains - 集合包含值
• -notcontains、-inotcontains、-cnotcontains - 集合不包含值
• -in - 值位于集合中
• -notin - 值不在集合中

类型

• -is - 这两个对象的类型相同
• -isnot - 对象类型不相同

Alias

内置别名

Get-Alias

[!tip] ls, pwd, cd 等指令在 power shell 仍然能够工作，就是得益于内置的 alias

为无参 cmdlet 创建 alias

# 将Get-AuthenticodeSignature创建别名gas
New-Alias -Name gas -Value Get-AuthenticodeSignature
# 将现有别名重新分配给其他 cmdlet
Set-Alias -Name gas -Value Get-Location
Get-Alias -Name gas

# 只读别名：防止误删除/修改
Set-Alias -Name loc -Value Get-Location -Option ReadOnly

# 创建可执行文件的别名
Set-Alias -Name np -Value C:\Windows\notepad.exe

若要更改或删除只读别名，请使用 Force 参数。

为有参命令创建 alias

不能为带有参数和值的命令（例如 Set-Location -Path C:\Windows\System32）创建别名。若要为某个命令创建别名，请创建一个包括该命令的函数，然后为此函数创建别名。

Function CD32 {Set-Location -Path C:\Windows\System32}
Set-Alias -Name Go -Value CD32

重定向输出

Out-File 将 powershell 的输出写入到文件。

# 直接写入
Get-Process | Out-File -FilePath .\Process.txt

# 防止覆盖现有文件
Get-Process | Out-File -FilePath .\Process.txt -NoClobber

以 ASCII 格式将输出发送到文件：

$Procs = Get-Process
Out-File -FilePath .\Process.txt -InputObject $Procs -Encoding ASCII -Width 50

• Encoding 参数将输出转换为 ASCII 格式
• -Width 参数将文件中的每一行限制为 50 个字符，因此某些数据可能会被截断。

关于异常

终止和非终止错误：异常通常是终止错误。引发的异常要么被捕获要么会终止当前执行程序。

默认情况下，Write-Error 会生成一个非终止错误，并将错误添加到输出流，而不引发异常。也就是说，Write-Error 和其他非终止错误不会触发 catch！

创建异常

若要创建自己的异常事件，可以使用 throw 关键字引发异常。

function Start-Something
{
    throw "Bad thing happened"
}

前面提到过，默认情况下 Write-Error 不会引发终止错误。但如果指定 -ErrorAction Stop，Write-Error 将会生成一个可使用 catch 处理的终止错误。

Write-Error -Message "Houston, we have a problem." -ErrorAction Stop

创建类型异常

throw [System.IO.FileNotFoundException] "Could not find: $path"

try/catch/finally

PowerShell（以及许多其他语言）中的异常处理方式是，先对一部分代码执行 try，如果引发终止错误，则对其执行 catch。可使用 $_ 变量访问 catch 块中的异常信息。

try
{
    Start-Something -ErrorAction Stop
}
catch
{
    Write-Output "Something threw an exception or used Write-Error"
    Write-Output $_
}

有时不需要处理错误，但无论异常是否发生，仍需要执行一些代码，则使用 finally。

处理异常

捕获类型化异常

try
{
    Start-Something -Path $path
}
catch [System.IO.DirectoryNotFoundException],[System.IO.FileNotFoundException]
{
    Write-Output "Could not find $path"
}
catch [System.IO.IOException]
{
        Write-Output "IO error with the file: $path"
}

脚本模块

将可复用的函数单独封装进 psm1 模块文件，然后引用

# common.psm1
function do-something {
...
}

然后在其他 ps1 文件中引入该模块

# script.ps1
Import-Module "/path/to/common.psm1" -DisableNameChecking

由于自定义函数/模块的名称未必严格符合 powershell 的 verb 格式，有时会报 warning，通常加上 -DisableNameChecking 忽略即可。

输出流

在 PowerShell 中，你可以使用 Write-Host 命令输出内容，并且可以通过修改输出的字体颜色和背景色来增加可读性。你可以使用 -ForegroundColor 和 -BackgroundColor 参数来设置文本的前景色（字体颜色）和背景色。此外，你也可以使用 \n 来添加换行符。

# 输出红色文本
Write-Host "This is red text" -ForegroundColor Red

# 输出黄色文本，蓝色背景
Write-Host "This is yellow text with blue background" -ForegroundColor Yellow -BackgroundColor Blue

# 输出包含换行符的文本
Write-Host "This is the first line`nThis is the second line"

# 使用变量输出带颜色的文本
$variable = "Important message"
Write-Host "The message is: $variable" -ForegroundColor Green

函数

函数参数 使用 param() 声明，可以在声明时指定参数类型。

function Validate-Path {
    # 验证输入路径、输出路径和视频文件格式
    param(
        [string]$i,
        [string]$o,
        [string]$f
    )
    ......
}

$input 是一个关键字，不可以作为参数使用。

函数返回值有多种形式：

1. 返回包含多个值的数组

   return @($i, $o, $f)
   

   返回值的获取

   $params = func
   Write-Host $params[0]  # 使用索引获取
   

2. 返回 key-value 形式的哈希表

   return @{
       key1 = $i
       key2 = $o
       key3 = $f
   }
   

   返回值的获取

   $params = func
   Write-Host $params.key1 # .key获取
   

执行默认操作

Invoke-Item 用于对指定项执行默认操作。例如在与某一文档文件类型关联的应用程序中打开该文档文件。

打开文件

Invoke-Item "C:\Test\a.doc"

# 打开特定类型的所有文件
Invoke-Item "C:\Users\User1\Documents\*.xls"

在文件资源管理器打开当前路径

Invoke-Item .

路径拼接

https://learn.microsoft.com/zh-cn/powershell/module/microsoft.powershell.management/join-path?view=powershell-7.4

网络

DNS

可以使用 Resolve-DnsName cmdlet 来测试一个 URL 的 DNS 查询记录。

Resolve-DnsName example.com [-Type MX] [-Server 8.8.8.8]

• 使用 -Type 参数指定要查询的 DNS 类型
• 使用 -Server 参数指定要使用的 DNS 服务器

Get-DnsClientServerAddress

这将显示操作系统当前配置的 DNS 服务器地址。通常情况下，你会看到一个或多个 DNS 服务器的 IP 地址。

路由表 Route

Get-NetRoute

Windows 路由表控制有一个内置命令 route，大概率是从 cmd 继承过来的。

# 打印路由表
route print

# 添加记录(临时)
route add $DestinationIP mask $SubMask $Gateway
# 删除记录
## 如果目标唯一的话，应该是不需要添加额外参数
route delete $DestinationIP

route print 打印出的路由表和 powershell Get-NetRoute cmdlet 打印的结果稍有不同。如下：

route print

IPv4 路由表
===========================================================================
活动路由:
网络目标        网络掩码          网关       接口   跃点数
          0.0.0.0          0.0.0.0   172.26.255.254   172.26.214.232    100
        127.0.0.0        255.0.0.0            在链路上         127.0.0.1    331

# powershell
Get-NetRoute


ifIndex DestinationPrefix                              NextHop                                  RouteMetric ifMetric PolicyStore
------- -----------------                              -------                                  ----------- -------- -----------
19      255.255.255.255/32                             0.0.0.0                                          256 35       ActiveStore
14      255.255.255.255/32                             0.0.0.0                                          256 25       ActiveStore

可以看见，主要区别在于 powershell 默认使用了 IP-CIDR 格式，因此相比于 route 命令缺少了子网掩码字段。

New-NetRoute

# 向路由表添加 IP
New-NetRoute -DestinationPrefix "10.0.0.0/24" -InterfaceIndex 12 -NextHop 192.168.0.1

注意，不同于 route add，Net-NetRoute 的子网掩码用 IP-CIDR 格式表示。

注意，不声明 PolicyStore 的情况下，会插入永久路由！

硬件相关

磁盘

# 常用于查看 MediaType (HDD 还是 SDD)
Get-PhysicalDisk

# 常用语查看盘符和磁盘名称
Get-Volume

管理服务 Service

获取服务

Get-Service

Get-Service -Name se*

Get-Service -DisplayName ServiceLayer, Server

• 不带参数将返回所有服务（Status / Name / DisplayName）
• 可以添加参数（如 -Name）进行筛选，支持通配符过滤或提供显示名称的列表

服务的 Name 和 DisplayName 并不总是一致！

有时服务的字段过长，导致终端中的输出被截取，可以通过 Format-Table 解决：

Get-Service -name razer* | Format-Table -AutoSize

获取必需和从属服务

# 获取 LanmanWorkstation 服务所依赖的服务。
Get-Service -Name LanmanWorkstation -RequiredServices

# 获取需要 LanmanWorkstation 服务的服务。
Get-Service -Name LanmanWorkstation -DependentServices

停止、启动、暂停和重启服务

# 停止服务
Stop-Service -Name spooler
# 启动服务
Start-Service -Name spooler
# 暂停服务
Suspend-Service -Name spooler
# 重启服务
Restart-Service -Name spooler

设置服务属性

Set-Service cmdlet 更改服务的属性，也可以启动、停止或暂停服务。

更改显示名称

Set-Service -Name LanmanWorkstation -DisplayName "LanMan Workstation"

更改服务的启动类型

Set-Service -Name BITS -StartupType Automatic

• Automatic - 服务将由操作系统在系统启动时启动或在系统启动时已启动。 如果自动启动的服务依赖于手动启动的服务，则手动启动的服务也会在系统启动时自动启动。
• AutomaticDelayedStart - 系统启动后不久启（延迟启动）。
• Disabled - 服务被禁用，不能由用户或应用程序启动。
• InvalidValue - 不起作用。 该 cmdlet 不返回错误，但服务的 StartupType 不会更改。
• Manual - 服务只能由用户（使用服务控制管理器）或应用程序手动启动。

更改服务的说明

# 查看 ipreport 服务当前 Description
Get-Service -Name ipreport | Select-Object Description
# 修改
Set-Service -Name ipreport -Description "ip report to whr"
# 查看修改结果
Get-Service -Name ipreport | Select-Object Description

处理多个服务

Set-Service cmdlet 一次只接受一个服务名称。 但是，可以通过管道将多个服务传递给 Set-Service，以更改多个服务的配置。

Get-Service SQLWriter,spooler |
    Set-Service -StartupType Automatic -PassThru |
    Select-Object Name, StartType

删除服务

# 移除名为 TestService 的服务
Remove-Service -Name "TestService"

# 移除使用显示名称的服务
Get-Service -DisplayName "Test Service" | Remove-Service

使用 -confirm 参数可以在运行 cmdlet 之前进行确认。

案例

如何调用已有脚本实现代码复用？

可以通过循环，在每次迭代中调用脚本。下面是一个示例代码，演示了如何在 PowerShell 中循环调用脚本来处理多个输入文件：

# 假设有一个包含多个输入文件的文件夹，路径为 $inputFolder
$inputFolder = "C:\Path\To\Input\Folder"

# 遍历输入文件夹中的所有文件
$inputFiles = Get-ChildItem -Path $inputFolder -File
foreach ($file in $inputFiles) {
    # 构建参数列表
    $params = @{
        inPath = $file.FullName
        outPath = "C:\Path\To\Output\Folder\" + $file.BaseName + "_converted.csv"
        inEncoding = "gb2312"  # 输入文件的编码格式
        outEncoding = "utf8"   # 想要转换成的编码格式
    }

    # 调用脚本并传入参数
    & "C:\Path\To\Your\Script.ps1" @params
}

英格力士 Teacher 布置了两篇看图写作的作业，在 U 校园的 iWrite 平台上。都 3202 年了，这种东西当然是 GPT 直接 μ 杀。结果......

当然，我敏锐的察觉到了地址栏那个大大的 不安全http 。心想这种臭鱼烂虾必有破解之法。苦寻油猴脚本无果的情况下，在另一个佬的博客里找到了答案

解决方案

先 F12 切开发者，然后定位到文本输入框

然后在右边的事件侦听器里，找到 paste 字段下的三个监听器，直接删了就行

葡萄种植

放条、埋土预测

因葡萄品种、土壤类型、含水量等条件不同，因此其放条、埋土的要求十分多变且难以预测。尤其是测量数据时，每次测量的微小误差累积起来后，会对预测结果产生较大影响。

全局信息化管理

咣咣砸钱，做过很多系统，都寄了。因为只采用了单一指标，没有从全局进行考虑，导致模型失败。以控水为例，防水8h或12h这种指标过于宽泛。实际情况下，不同季节需水完全不同。因此，信息化管理应当结合天气预测，利用气象驱动。

要在空间体系上，实现经济、生态、水丰效益的最优化。（做梦呢）

智慧果园

死系统，信息分散，没有整体化、全局化系统。应当结合土壤、天气信息，利用气象动因驱动系统。

气象

图像处理

分辨率不够(业内术语称为降尺度、差值？)。

数据质量控制：

1. 对不对
2. 补全

数据采集

高光谱、植物长势、物联网、灾情数据

数据处理

very important! 从历史数据中，找出线性、非线性的联系，进行预报预测，得出以下几个方面的结论：

• when: 啥时候种
• which: 种啥
• manage: 全链条智慧管理

  我就纳闷了，整个蓝不拉几的科技风 UI 界面就智慧了？那还不如买华为呢，华为给我增智慧！

图像识别

• 农民伯伯/姨姨拍张照，识别出来什么虫？用什么药？在哪里买？
• 无人机拍照，分析作物长得咋样，有没有什么病虫害

其他

• 粮食安全
• 自然灾害预测
• 干旱管理
• 太阳能

产量预报

对方目前采用的仍是统计、经验、大数据模型等手段。但对于无法量化的数据，没有好的解决方案，如：

1. 国家、自治区的政策、文件
2. 灾情（主要是气象）
3. 人工调查信息
4. 多部门会商的结果
5. 技术发展（例如加大某方面投入）
6. 实时数据（农业部、气象站）
7. 指标数据
8. ......

农事活动监测