Celyn's Blog

【Claude_Code_CLI安装】代理配置-本地模型-插件生态

Sat, 23 May 2026 00:00:00 GMT

1 前言#

最近在使用Claude Code (简称 cc )帮助我进行日常学习、项目开发，本文记录下 Claude Code CLI 的安装、DeepSeek 模型配置、llama.cpp 本地模型内网穿透后进行公网连接的操作，最后简单提及下 skill、plugin 等功能的安装，后续也会更新下 cc 的一些进阶操作。

2 安装#

先安装 Git 与 Node.js。

Terminal window

1
# 国内用户（winget 源）
2
winget install Anthropic.ClaudeCode
3

4
# 官方渠道（npm 全局安装）
5
npm install -g @anthropic-ai/claude-code

安装完成后，在终端输入 claude 即可启动。

3 `cc switch` 多模型配置切换#

下载：CC Switch

cc switch 用于在多个模型配置之间快速切换，并对齐模型所需格式。

4 配置 DeepSeek 兼容端点#

Claude Code 默认走 Anthropic 官方 API，但也可以通过自定义端点接入 DeepSeek 等兼容模型，降低成本。

4.1 获取 API Key#

前往 DeepSeek 开放平台申请 API Key，然后在 Claude Code 中配置。

4.2 配置自定义端点#

使用 cc switch 创建一套新配置，填入 DeepSeek 的 API 地址和 Key 即可。

注意：DeepSeek 兼容的是 OpenAI API 格式，Claude Code 内部已做适配，直接使用社区提供的端点地址即可。

点击获取模型列表，再点击一键设置即可记得勾选1M，表示可以使用1百万token上下文，当然前提是你的模型支持(比如deepseek)

5 接入本地模型（llama.cpp）#

llama.cpp 默认提供的是 OpenAI 兼容 API，而 Claude Code 走的是 Anthropic 协议。直接在 settings.json 里填 llama.cpp 的地址是不行的，需要配合 cc switch 的自定义端点功能来桥接。

5.1 内网穿透（ngrok）#

使用 ngrok 进行内网穿透，下载客户端即可使用

如果 llama.cpp 跑在本地，想让外网也能访问（比如在另一台机器上用 Claude Code），可以用 ngrok 做内网穿透，把本地端口暴露到公网：

Terminal window

1
ngrok http 8080

5.2 在 Claude Code 中连接 llama.cpp#

配置步骤如下：

如果 llama.cpp 没有配置 API Key，cc switch 处的 API Key 可以随意填写，不会校验。
输入请求地址后，点击管理与测速，测试是否连通。
点击高级选项展开。
点击获取模型列表（上方弹窗会显示获取到的模型数量）。
在模型下拉列表中选择你的模型。
点击一键设置。
保存配置。

注意：请保持 API 格式与认证字段不变，不要随意修改。

配置完成后，在任意文件夹打开终端输入 claude，测试是否正常启用。

5.3 切换模型#

在 cc switch 界面中，你可以随时在不同配置之间切换——远程大模型干活，本地小模型摸鱼，灵活选择。

5.4 缺点#

存在这样一种情景，我需要同时使用多家大模型，但是ccswitch只能选择启用一个供应商。

而且由于目前deepseek v4仅为文本推理llm，不具备图片理解能力，导致我必须额外配置一个具有视觉的大模型，此时我就必须使用python自己写一个网关脚本，用于对齐agent要求的格式并连接上我视觉模型，当然我们可以将其配置成全局skill，当需要视觉理解时进行调用。

5.5 CC switch实际修改配置#

cc switch实际就是建立网关，将baseurl改成自己的端口，再填写供应商的api调用地址和映射模型进行模型调用

6 Skill、Plugin、Agent 扩展#

Claude Code 的真正威力在于可扩展生态。通过插件市场，你可以安装社区提供的 Skill、Plugin 和 Agent，极大扩展能力边界。

6.1 添加市场#

首先添加 Anthropic 官方市场：

1
/plugin marketplace add anthropics/skills

市场地址：https://github.com/anthropics/skills

6.2 浏览与安装#

添加市场后，输入 /plugin 即可浏览所有可用插件。按需安装，最后执行一次插件重载/reload-plugin即可生效。

安装完成后，右下角状态栏会显示各服务的可用状态。如果某个 MCP 服务启动失败或需要官方验证，也会有相应提示，方便排查。

7 小结#

场景	方案
安装使用	官方地址或`winget`安装
模型接入	DeepSeek + `cc switch`
本地模型	llama.cpp 本地模型 + `cc switch`
扩展能力	Marketplace 安装 Skill / Plugin

折腾一圈下来，Claude Code CLI 就配置好了—— 一套工具，多种后端模型，按需切换。希望这篇笔记能帮你少走弯路。

【Git】项目协作开发教程

Tue, 19 May 2026 00:00:00 GMT

1 前言#

近期，我在 GitHub 平台参与项目协同开发的过程中，系统掌握了规范的 Git 操作流程。从遵循 Conventional Commit 规范撰写提交信息，到将代码提交至 Fork 后的个人仓库，再到通过 Pull Request（PR）向上游原仓库贡献代码，每一个环节都经过实践打磨，逐步形成了标准化的操作习惯。为了梳理所学、方便后续查阅，同时也为有类似协作需求的开发者提供参考，特此整理这份 Git 操作指南，涵盖从基础配置到协作收尾的全流程，力求步骤清晰、重点突出、可直接使用。

2 Git 基础全局配置#

在使用 Git 前，需先配置全局用户名和邮箱，这是提交代码时的身份标识，仅需配置一次。

1
# 配置全局用户名（替换为你的 GitHub 用户名）
2
git config --global user.name "Celyn"
3

4
# 配置全局邮箱（替换为你的 GitHub 绑定邮箱）
5
git config --global user.email "1249140039@qq.com"

2.1 验证配置是否成功#

执行以下命令，查看已配置的用户名和邮箱：

1
# 查看用户名
2
git config user.name
3

4
# 查看邮箱
5
git config user.email

==注意==：请务必确认好本地 Git 用户配置是否生效。

小故事😢：我在实验室电脑执行 git push、提交 PR 时，由于疏忽检查，提交记录带入电脑里留存的其他用户信息，导致 pr 时对方被设为共同作者，并且在我 fork 的仓库中显示上传 commit的用户并不是自己。所以一定要提前核对清楚本地个人账号信息，不然你的辛苦付出最后反倒会为他人做了嫁衣。

注：pr 里面多了个不知名的 xxxu680

3 Git 代理配置（解决 GitHub 下载慢）#

若访问 GitHub 速度缓慢，可配置 7897 端口代理（本地常用代理端口），提升克隆、拉取代码的效率。

3.1 设置 7897 端口代理#

适用于 http/https 协议下载 GitHub

1
# 配置 HTTP 代理
2
git config --global http.proxy http://127.0.0.1:7897
3

4
# 配置 HTTPS 代理
5
git config --global https.proxy https://127.0.0.1:7897

3.2 验证代理是否生效#

1
# 查看 HTTP 代理
2
git config --global --get http.proxy
3

4
# 查看 HTTPS 代理
5
git config --global --get https.proxy

3.3 取消代理（备用）#

若无需代理，可执行以下命令清除配置：

1
# 取消 HTTP 代理
2
git config --global --unset http.proxy
3

4
# 取消 HTTPS 代理
5
git config --global --unset https.proxy

4 Fork 仓库与本地初始化#

4.1 Fork 上游仓库#

以==我参与开发的项目==为例：在 GitHub 上将目标仓库（如 jihe520/MathModelAgent）Fork 到自己的账号下，生成个人副本（如 HP-Patience/MathModelAgent）。

4.2 本地初始化仓库#

4.2.1 方式 1：下载 ZIP 压缩包后初始化#

下载 Fork 后仓库的 .zip 压缩包，解压到本地目录；
进入目录，执行 git init 初始化 Git 仓库；
关联自己的远程仓库（origin） 和上游原仓库（upstream）：

Terminal window

1
# 关联自己的 Fork 仓库（origin）
2
git remote add origin https://github.com/HP-Patience/MathModelAgent.git
3

4
# 关联上游原仓库（upstream，用于同步最新代码）
5
git remote add upstream https://github.com/jihe520/MathModelAgent.git

拉取最新代码到本地：

Terminal window

1
git pull origin main

4.2.2 方式 2：直接 Git Clone（推荐）#

git clone 会自动执行 git init + 关联远程仓库 + 下载完整最新代码，无需手动初始化和拉取：

Terminal window

1
# 克隆自己的 Fork 仓库到本地
2
git clone https://github.com/HP-Patience/MathModelAgent.git

5 分支开发与代码提交#

5.1 创建开发分支#

永远不要直接在 main 分支修改代码，需创建独立开发分支：

1
# 创建并切换到 myfeat 分支（分支名可自定义）
2
git checkout -b myfeat

5.2 修改代码与提交#

在 myfeat 分支完成代码修改后，提交变更：

1
# 添加所有修改文件
2
git add .
3

4
# 提交代码（添加清晰的提交信息）
5
git commit -m "feat: 完成XX功能开发"

==注意==：请使用 conventional commit 进行提交内容说明

6 同步上游更新与推送代码#

6.1 场景 1：上游仓库无新提交#

若原仓库（upstream）未更新代码，直接将本地分支推送到自己的远程仓库：

1
# 将 myfeat 分支推送到自己的 GitHub 仓库
2
git push origin myfeat

6.2 场景 2：上游仓库有新提交#

若原仓库已更新，需先同步上游代码，再推送，避免冲突：

切换回 main 分支，拉取上游最新代码：

1
git checkout main
2
git pull upstream main

切换回开发分支，将上游代码合并到当前分支：

1
git checkout myfeat
2
git rebase main

若出现 rebase 冲突，手动修改冲突文件后，继续 rebase；
无冲突或冲突解决后，强制推送到自己的远程仓库（必须加 -f）：

1
git push -f origin myfeat

6.3 提交 PR 到上游仓库#

进入自己的 GitHub 仓库（HP-Patience/MathModelAgent）；
点击 Compare & pull request，选择目标分支；
填写 PR 说明，提交后等待原仓库作者审核即可。

7 PR 被合并后：同步代码 + 清理分支#

当你的 PR 被上游仓库合并完成后，执行以下命令同步代码并清理无用分支：

1
# 1. 切换到本地 main 分支
2
git checkout main
3

4
# 2. 拉取上游最新代码（包含你刚合并的功能）
5
git pull upstream main
6

7
# 3. 删除本地已完成的开发分支（强制删除）
8
git branch -D myfeat
9

10
# 4.（可选）同步到你自己的远程 main 分支
11
git push origin main

7.1 常见问题提示#

代理报错 URL拼写可能存在错误：检查代理地址是否为 127.0.0.1:7897，确认本地代理服务已启动；
Rebase 冲突：打开冲突文件，删除冲突标记（<<<<<<</=======/>>>>>>>），保留正确代码后重新执行；
推送失败：确认分支权限，非 main 分支无需强制推送，更新上游后务必加 -f 强制推送。
删除分支报错：使用大写 -D 强制删除已合并完成的开发分支。

8 总结#

本文介绍了从配置 → 克隆 → 开发 → 提交 → 同步 → 提PR → 清理的完整闭环 Git 协作流程，所有命令都是团队开源协作最标准的用法，可以直接使用。

【n8n】基于WSL2-Docker完整部署教程

Tue, 12 May 2026 00:00:00 GMT

1 引言：为什么使用 n8n#

n8n 是一款开源免费低代码自动化工作流工具，支持可视化拖拽、对接海量第三方服务（数据库、企业微信、飞书、网盘、接口等），可自建部署、数据私有不托管，搭配 WSL2 + Docker 一键部署，轻量化不占用 Windows 主环境，方便日常自动化流程搭建、定时任务、数据同步等场景。

2 WSL 下载配置#

2.1 WSL 内核更新#

在 CMD/PowerShell 里输入：

Terminal window

1
wsl --update

等待自动下载安装 WSL2 内核，跑完就好了。

2.2 手动安装 Ubuntu22.04（清华镜像离线导入）#

使用清华镜像源进行下载，点击该链接后：如果你电脑是 Windows 64 位，下滑找到jammy-server-cloudimg-amd64-root.tar.xz下载即可

下载好后操作把文件放到：F:\wsl\，没有文件夹自行创建即可
接着打开 CMD 或者 PowerShell创建文件夹，输入：

Terminal window

1
mkdir F:\wsl\Ubuntu2204

接着导入安装，运行：

Terminal window

1
wsl --import Ubuntu-22.04 F:\wsl\Ubuntu2204 F:\wsl\jammy-server-cloudimg-amd64-root.tar.xz --version 2

等着跑完就行，几分钟搞定，直接装在 F 盘。

2.3 常见报错处理：#

2.3.1 开启系统必要功能（管理员 PowerShell 逐条执行）#

Terminal window

1
dism.exe /online /enable-feature /featurename:Microsoft-Windows-Subsystem-Linux /all /norestart
2
dism.exe /online /enable-feature /featurename:VirtualMachinePlatform /all /norestart
3
dism.exe /online /enable-feature /featurename:Hyper-V-Online /all /norestart

2.3.2 图形化检查 Windows 功能#

按下 Win + R 输入 optionalfeatures.exe 回车
查看是否勾选下面 3 个，若无则打勾：

✅ Windows 子系统用于 Linux
✅ 虚拟机平台
✅ Hyper-V（能看到就勾）

确定后重启电脑。

2.3.3 开启 CPU 虚拟化#

重启开机马上按 Del / F2 / F1 进 BIOS：

Intel 找：Intel VT-x 设为 Enabled
AMD 找：AMD-V / SVM Mode 设为 Enabled

保存退出重启。

2.3.4 重新执行导入命令#

Terminal window

1
wsl --import Ubuntu-22.04 F:\wsl\Ubuntu2204 F:\wsl\jammy-server-cloudimg-amd64-root.tar.xz --version 2

3 Docker下载与配置#

3.1 Docker Desktop下载#

Docker Desktop下载链接

3.2 Docker Resources#

3.2.1 Advanced 设置#

修改 Disk image location，把 Docker 存储路径迁移到非 C 盘。

3.3 WSL integration 配置#

开启对应 Ubuntu-22.04 的 WSL 集成，让 Docker 与 WSL 互通

3.4 Docker Engine 镜像加速配置#

粘贴以下完整配置，配置国内镜像源加速拉取：

1
{
2
  "builder": {
3
    "gc": {
4
      "defaultKeepStorage": "20GB",
5
      "enabled": true
6
    }
7
  },
8
  "experimental": false,
9
  "features": {
10
    "buildkit": true
11
  },
12
  "registry-mirrors": [
13
    "https://docker.1ms.run",
14
    "https://docker.xuanyuan.me",
15
    "https://registry-1.docker.io"
16
  ]
17
}

展开收起

配置后重启 Docker 生效。

4 n8n 部署与使用#

4.1 Docker 部署启动 n8n#

在bash中输入docker命令：

创建持久化数据卷

Terminal window

1
docker volume create n8n_data

启动 n8n 容器（时区设为上海、端口映射、数据持久化）

1
docker run -d ` --name n8n ` -p 5678:5678 ` -e GENERIC_TIMEZONE="Asia/Shanghai" ` -e TZ="Asia/Shanghai" ` -v n8n_data:/home/node/.n8n ` n8nio/n8n

访问地址

浏览器打开：http://localhost:5678/

同时在docker desktop中的Containers中出现该容器

4.2 n8n 的webui界面操作#

5 参考文档：#

神经网络优化核心：鞍点而非局部极小值

Sun, 10 May 2026 00:00:00 GMT

1 前言#

当模型在训练集上损失居高不下，且增加模型复杂度后损失未降反升时，问题通常不在于模型 bias，而在于优化过程本身——梯度下降易在高维损失景观中被困于鞍点，本文结合 Hessian 矩阵与实验证据，梳理相关核心结论。

2 梯度下降收敛停滞的关键原因#

梯度下降过程中，当梯度∇L (θ)=0 时，损失函数值不再变化，优化陷入停滞。造成这一现象的原因并非仅为局部最小值点，还可能是鞍点，两者核心区别如下：

局部最小值点（local minimum point）：梯度为 0，且任意方向移动损失均增大，优化达到局部最优；
鞍点（saddle point）：梯度为 0，存在一对正交方向，沿其中一个方向移动损失增大，沿另一个方向移动损失减小，并非最优解，却会导致梯度下降停滞。

综上，局部最小值点与鞍点的梯度均为 0，这两类梯度为 0 的点统称为驻点。

那么当我们遇到梯度为 0 的驻点时，如何判断其是局部最小值点还是导致优化停滞的鞍点呢？此时需要引入 Hessian 矩阵进行判别：

3 Hessian 矩阵与二次型#

要判断一个临界点到底是什么，我们需要用到二阶泰勒展开，在临界点 θ′\theta'θ′ 附近近似损失函数：

L(θ)≈L(θ′)+12(θ−θ′)TH(θ−θ′)L(\theta) \approx L(\theta') + \frac{1}{2} (\theta - \theta')^T H (\theta - \theta')L(θ)≈L(θ′)+21(θ−θ′)TH(θ−θ′)

这里的 HHH 就是Hessian 矩阵，是由损失函数 L (θ) 各参数的二阶偏导数构成的对称方阵，用于刻画损失函数曲率，辅助判断驻点类型。

我们设 v=θ−θ′v = \theta - \theta'v=θ−θ′（移动方向），那么损失的变化就完全由二次项决定：

ΔL≈12vTHv\Delta L \approx \frac{1}{2} v^T H vΔL≈21vTHv

而根据特征向量的定义，对于 Hessian 的特征向量 uuu 和对应的特征值 λ\lambdaλ，我们有：

uTHu=λ∥u∥2u^T H u = \lambda \|u\|^2uTHu=λ∥u∥2

因为 ∥u∥2>0\|u\|^2 > 0∥u∥2>0，所以 uTHuu^T H uuTHu 的符号完全由特征值 λ\lambdaλ 决定：

λ>0\lambda > 0λ>0：沿 uuu 方向走，损失会变大（上坡）。
λ<0\lambda < 0λ<0：沿 uuu 方向走，损失会变小（下坡）。

这就是为什么我们可以用 Hessian 的特征值来判断临界点的类型。

4 收敛点的真实本质#

我们可以做一个简单的实验：重复训练同一个网络很多次，每次训练到收敛，然后计算每个临界点 Hessian 矩阵的正特征值比例（我们称之为 Minimum Ratio），并记录对应的训练损失。

我们能从实验结果中清晰地看到一个强规律：

左侧点群（Minimum Ratio 很低）：损失都很高（0.08-0.09），这些是典型的低维鞍点，有大量负特征值，模型困在这里根本没学好。
右侧点群（Minimum Ratio 很高）：损失都很低，这些点看起来像“局部极小值”，但它们的 Minimum Ratio 远小于 1，说明 Hessian 矩阵里仍然存在少量负特征值，本质上还是鞍点。

图中的文字 never reach a real "local minima" 直接点破了真相： 我们几乎永远无法到达数学上严格定义的局部极小值，只能停在这些高维鞍点上。

5 总结#

高维空间中，鞍点数量远多于局部极小值，是模型收敛的主要位置，且鞍点可进一步优化，并非优化终点；
驻点类型可通过 Hessian 矩阵特征值判断：所有特征值>0 为局部最小值点，正负特征值共存为鞍点；
可沿 Hessian 负特征值对应的特征向量方向，逃离劣质鞍点，继续降低损失；
优化的关键并非追求严格局部极小值，而是收敛到负特征值少、正特征值占比偏高的平缓优质临界点，这类点损失更低、泛化性能更好。

【IP地址防护】-预防WebRTC泄露

Sat, 02 May 2026 00:00:00 GMT

什么是 WebRTC 泄露（WebRTC Leak），如何预防#

WebRTC（Web Real-Time Communication）是浏览器提供的实时音视频与点对点数据通道技术。WebRTC 泄露 指的是在使用浏览器或某些应用时，WebRTC 的连接流程（ICE 候选交换）意外暴露了本地或真实公网 IP 地址，导致即便你在用 VPN/代理，目标网站或第三方仍可能看到你的真实 IP 地址或局域网地址，从而破坏隐私与匿名性。

WebRTC 泄露简要原理

建立 P2P 连接时，浏览器会通过 STUN/TURN server 获取 ICE candidates（候选连接地址），这些候选包括：
- host（本机局域网 IP）
- srflx（通过 STUN 获得的公网映射 IP）
- relay（通过 TURN 中继的地址）
如果浏览器本地或网页脚本暴露/发送了 host 或 srflx 类型的候选，第三方就可能获知本机真实 IP（包括局域网 IP 与公网真实 IP）。
VPN/代理通常只影响浏览器的普通 HTTP(S) 流量，但 WebRTC 的 STUN 请求可能绕过这些路径，从而暴露真实地址。

chrome需要安装扩展来避免WebRTC 泄露，推荐一个开源扩展 chrome扩展地址

使用 IPPure 检查 WebRTC 泄露情况#

安装前：#

IPPure链接地址

安装后：#

Reference：#

WebRTC解释

【爬虫脚本自动化录制】playwright-codegen使用教程

Tue, 14 Apr 2026 00:00:00 GMT

前言#

在做 Web 自动化测试、爬虫脚本开发时，手动写定位、写操作步骤往往耗时又容易出错。Playwright 官方提供了一个零代码录制神器：codegen，只需要在浏览器里用鼠标点击，就能自动生成可直接运行的 Python/Java/JS 自动化代码，极大提升开发效率。

什么是 playwright codegen？#

codegen 是 Playwright 内置的交互式录制工具，核心功能：

记录鼠标点击、输入、选择、滚动、切换页面等操作
实时生成高质量、可直接运行的代码
自动识别 iframe、弹窗、下拉框等复杂场景
支持 Python / Node. js / Java / C# 多语言导出

适用场景：快速生成登录脚本、表单提交、页面遍历、爬虫操作等。

环境准备#

安装 Playwright#

Terminal window

1
pip install playwright

安装浏览器驱动#

Terminal window

1
playwright install

会自动安装 Chromium、Firefox、WebKit 内核。

codegen 基础使用#

直接启动录制#

Terminal window

1
playwright codegen 网址

示例：打开百度并录制

Terminal window

1
playwright codegen https://www.baidu.com

执行后会弹出两个窗口：

左侧：浏览器页面（你手动操作）
右侧：Playwright Inspector（实时生成代码）

操作演示#

在百度搜索框输入“CSDN”
点击“百度一下”
等待页面跳转
关闭浏览器

右侧会自动生成完整 Python 代码，复制即可直接运行。生成代码如下：

1
import re
2
from playwright.sync_api import Playwright, sync_playwright, expect
3

4

5
def run(playwright: Playwright) -> None:
6
    browser = playwright.chromium.launch(headless=False)
7
    context = browser.new_context()
8
    page = context.new_page()
9
    page.goto("https://www.baidu.com/")
10
    page.get_by_role("textbox", name="中央音乐学院教授安平病逝").click()
11
    page.get_by_role("textbox", name="中央音乐学院教授安平病逝").fill("CSDN")
12
    page.get_by_role("button", name="百度一下").click()
13

14
    # ---------------------
15
    context.close()
16
    browser.close()
17

18

19
with sync_playwright() as playwright:
20
    run(playwright)

展开收起

常用高级参数#

参数	作用	示例
`-o 文件名.py`	将录制代码保存到文件	`playwright codegen -o test.py https://www.baidu.com`
`--browser`	指定浏览器（chromium/firefox/webkit）	`--browser firefox`
`--device`	模拟手机设备	`--device "iPhone 15"`
`--slowmo 毫秒`	慢放操作，避免录制过快	`--slowmo 1000`
`--lang`	指定生成语言（python/js/java/csharp）	`--lang java`
`--viewport`	指定窗口大小	`--viewport 1920,1080`

常用组合示例：

Terminal window

1
# 录制并保存，慢放 1 秒，模拟 iPhone 15
2
playwright codegen -o auto_test.py --slowmo 1000 --device="iPhone 15" https://www.baidu.com

实战案例：录制 CSDN 登录脚本#

开始录制#

Terminal window

1
playwright codegen -o csdn_login.py https://passport.csdn.net/login

手动操作步骤#

选择“密码登录”
输入用户名
输入密码
处理滑块/验证（手动完成）
点击登录

自动生成代码示例#

1
from playwright.sync_api import Playwright, sync_playwright, expect
2

3
def run(playwright: Playwright) -> None:
4
    browser = playwright.chromium.launch(headless=False)
5
    context = browser.new_context()
6
    page = context.new_page()
7
    page.goto("https://passport.csdn.net/login")
8

9
    # 切换密码登录
10
    page.get_by_role("tab", name="密码登录").click()
11
    # 输入账号
12
    page.get_by_placeholder("手机号/邮箱/账号").click()
13
    page.get_by_placeholder("手机号/邮箱/账号").fill("你的账号")
14
    # 输入密码
15
    page.get_by_placeholder("请输入密码").click()
16
    page.get_by_placeholder("请输入密码").fill("你的密码")
17
    # 登录
18
    page.get_by_role("button", name="登录").click()
19

20
    # ---------------------
21
    context.close()
22
    browser.close()
23

24
with sync_playwright() as playwright:
25
    run(playwright)

展开收起

录制后代码必须优化#

codegen 生成的代码能跑，但不够健壮，建议优化：

添加显示等待（防止页面未加载）#

1
page.get_by_role("button", name="登录").wait_for(state="visible")

使用 expect 断言#

1
expect(page.get_by_role("button", name="登录")).to_be_enabled()

1
# 1.断言“验证码登录”文字对应的元素在页面上可见，用于判断登录区域加载完成
2
expect(page.get_by_text("验证码登录")).to_be_visible()
3

4
# 2.断言页面 body 中包含“登录可享更多权益”文本，用于校验页面是否正常加载
5
expect(page.locator("body")).to_contain_text("登录可享更多权益")
6

7
# 3.可选取复制页面文字
8

9
# 4.校验元素的无障碍 ARIA 属性是否匹配，由 codegen 自动生成，实际使用中一般可删除
10
expect(page.locator("#thirdLogin")).to_match_aria_snapshot("")

处理 iframe#

如果页面嵌套 iframe，codegen 会自动生成 frame_locator，建议精简：

1
login_frame = page.frame_locator("iframe[name='login_frame']")
2
login_frame.get_by_text("登录").click()

去掉冗余操作#

删除重复的 click()、无用的等待和多余定位。

同文收录于CSDN：文章链接

【爬虫项目解析】-小鹅通m3u8逆向解密

Mon, 30 Mar 2026 00:00:00 GMT

打开 F12, 勾选保留日志，进行手动登录，找到请求方法为 POST 的信息，这就是登录时向服务器发送的请求，找到 cookie 的信息并记录。

点击负载可以找到发起登录请求时传入的参数信息

ticket：验证码票据（用来校验你输入的验证码）
randstr：随机字符串（防重放攻击）
verification_type：验证类型（1 通常代表密码登录）
session_id：当前会话 ID
phone：你的登录手机号（明文）
password：你的密码（这里看起来是部分掩码显示，实际传输时大概率是加密或脱敏后的）
keep_login：是否记住登录状态（false 代表不记住）
nation_login：国家 / 地区登录标识（1 通常代表国内）

播放视频时产生一系列 Session 会话，这些视频相关行都是客户端向服务器请求的视频分片 TS分片的会话，类型时 video/mp2t，也就是 HLS 流媒体切片文件，第四第五列分别是目标服务器域名以及请求的视频分片 url 路径，但是知识 ts 切片，需要找到完整的 m3u8 文件。

ctrl+f 搜索 m3u8 的session会话

请求头中包含 url 信息，需要加上 host 域名前缀

未完…

【cv-AI攻防】-Task1：赛题方案解读

Sat, 12 Oct 2024 00:00:00 GMT

步骤一：构建YOLO数据集#

由于比赛原始数据集较大，我们采样部分数据构建训练集和验证集：

1
if os.path.exists('yolo_seg_dataset'):
2
    shutil.rmtree('yolo_seg_dataset')
3

4
os.makedirs('yolo_seg_dataset/train')
5
os.makedirs('yolo_seg_dataset/valid')
6

7
def normalize_polygon(polygon, img_width, img_height):
8
    return [(x / img_width, y / img_height) for x, y in polygon]
9

10
# 采样训练集
11
for row in training_anno.iloc[:10000].iterrows():
12
    shutil.copy(row[1].Path, 'yolo_seg_dataset/train')
13

14
    img = cv2.imread(row[1].Path)
15
    img_height, img_width = img.shape[:2]
16
    txt_filename = os.path.join('yolo_seg_dataset/train/' + row[1].Path.split('/')[-1][:-4] + '.txt')
17
    with open(txt_filename, 'w') as up:
18
        for polygon in row[1].Polygons:
19
            normalized_polygon = normalize_polygon(polygon, img_width, img_height)
20
            normalized_coords = ' '.join([f'{coord[0]:.3f} {coord[1]:.3f}' for coord in normalized_polygon])
21
            up.write(f'0 {normalized_coords}\n')
22

23
 # 采用验证集
24
 for row in training_anno.iloc[10000:10150].iterrows():
25
    shutil.copy(row[1].Path, 'yolo_seg_dataset/valid')
26

27
    img = cv2.imread(row[1].Path)
28
    img_height, img_width = img.shape[:2]
29
    txt_filename = os.path.join('yolo_seg_dataset/valid/' + row[1].Path.split('/')[-1][:-4] + '.txt')
30
    with open(txt_filename, 'w') as up:
31
        for polygon in row[1].Polygons:
32
            normalized_polygon = normalize_polygon(polygon, img_width, img_height)
33
            normalized_coords = ' '.join([f'{coord[0]:.3f} {coord[1]:.3f}' for coord in normalized_polygon])
34
            up.write(f'0 {normalized_coords}\n')

展开收起

逐行代码分析#

好的，我们逐行分析这段代码，它的主要功能是将训练集和验证集的数据从原始数据集中复制到新的目录中，并将多边形的坐标标准化为相对坐标。

代码逐行分析#

1
if os.path.exists('yolo_seg_dataset'):
2
    shutil.rmtree('yolo_seg_dataset')

功能: 检查yolo_seg_dataset目录是否存在。如果存在，则使用shutil.rmtree删除该目录及其内容。shutil常用于文件与目录的处理。
目的: 确保每次运行代码时，数据集是干净的，没有旧的数据。

1
os.makedirs('yolo_seg_dataset/train')
2
os.makedirs('yolo_seg_dataset/valid')

功能: 创建两个新的子目录train和valid，用于存放训练集和验证集数据。
目的: 为之后的文件复制和标签文件创建所需的目录结构。

1
def normalize_polygon(polygon, img_width, img_height):
2
    return [(x / img_width, y / img_height) for x, y in polygon]

功能: 定义一个函数normalize_polygon，它接受一个多边形的坐标（列表形式），以及图像的宽度和高度。该函数返回归一化后的坐标，归一化的方式是将每个坐标除以图像的宽度和高度。
目的: ==将坐标转换为相对坐标，使其在不同尺寸的图像中具有一致性==。

1
# 采样训练集
2
for row in training_anno.iloc[:10000].iterrows():

功能: 遍历training_anno数据框的前10000行。iterrows()方法用于逐行迭代数据框，并返回行的索引和行的内容。
目的: 处理训练集中的前10000条数据。

1
    shutil.copy(row[1].Path, 'yolo_seg_dataset/train')

功能: 将当前行的图像文件从原始路径复制到yolo_seg_dataset/train目录。
目的: 将图像文件放入训练集目录中。

1
    img = cv2.imread(row[1].Path)
2
    img_height, img_width = img.shape[:2]

功能: 使用OpenCV读取图像文件，并获取其高度和宽度。
目的: 获取图像的尺寸，以便后续进行坐标归一化。

1
    txt_filename = os.path.join('yolo_seg_dataset/train/' + row[1].Path.split('/')[-1][:-4] + '.txt')

功能: 生成对应的文本文件名，该文件名是基于图像文件名生成的（去掉扩展名并添加.txt）。
目的: 为每个图像文件创建一个对应的标签文件。

1
    with open(txt_filename, 'w') as up:

功能: 打开或创建文本文件进行写入，使用with语句可以确保文件在写入完成后正确关闭。
目的: 准备写入归一化后的坐标数据。

1
        for polygon in row[1].Polygons:
2
            normalized_polygon = normalize_polygon(polygon, img_width, img_height)

功能: 遍历当前行的所有多边形坐标，调用normalize_polygon函数进行归一化。
目的: 将多边形的坐标转化为相对坐标。

1
            normalized_coords = ' '.join([f'{coord[0]:.3f} {coord[1]:.3f}' for coord in normalized_polygon])

功能: 这是一个列表推导式，用于遍历normalized_polygon中的每个坐标coord。每个coord都是一个包含两个元素的元组（(x, y)），表示一个点的坐标。
格式化:
- coord[0]:.3f：将coord中的第一个元素（x坐标）==格式化为小数点后三位的浮点数==。
- coord[1]:.3f：将第二个元素（y坐标）格式化为小数点后三位的浮点数。
结果: 列表推导式生成一个字符串列表，其中每个字符串都包含格式化后的坐标，例如：["0.123 0.456", "0.789 0.012"]。

1
            up.write(f'0 {normalized_coords}\n')

内容:
- '0 '：这是一个常量字符串，通常用于表示==类别标签==。在YOLO格式中，0可能表示某个特定的类别（例如，一个物体的类别，具体取决于数据集的类别定义）。
- up是一个文件对象，通过with open(...) as up:创建的。调用write方法将构建的字符串写入到文件中。
功能: 将归一化后的坐标写入文本文件。
目的: 保存标签信息，以便YOLO模型使用。

验证集处理#

接下来的代码与训练集处理相似，只是处理的是验证集数据。它从training_anno的第10000到第10150行进行迭代，重复上述步骤，复制图像到yolo_seg_dataset/valid目录，并创建相应的标签文件。

1
# 采用验证集
2
for row in training_anno.iloc[10000:10150].iterrows():
3
    shutil.copy(row[1].Path, 'yolo_seg_dataset/valid')
4

5
    img = cv2.imread(row[1].Path)
6
    img_height, img_width = img.shape[:2]
7
    txt_filename = os.path.join('yolo_seg_dataset/valid/' + row[1].Path.split('/')[-1][:-4] + '.txt')
8
    with open(txt_filename, 'w') as up:
9
        for polygon in row[1].Polygons:
10
            normalized_polygon = normalize_polygon(polygon, img_width, img_height)
11
            normalized_coords = ' '.join([f'{coord[0]:.3f} {coord[1]:.3f}' for coord in normalized_polygon])
12
            up.write(f'0 {normalized_coords}\n')

总结#

这段代码的主要目的是将多边形标注数据从原始数据集中提取出来，规范化并保存到新的训练集和验证集目录中，以供YOLO模型使用。通过归一化坐标，模型可以更好地适应不同尺寸的输入图像。

步骤二：写入YOLO配置文件#

1
with open('yolo_seg_dataset/data.yaml', 'w') as up:
2
    data_root = os.path.abspath('yolo_seg_dataset/')
3
    up.write(f'''
4
path: {data_root}
5
train: train
6
val: valid
7

8
names:
9
    0: alter
10
''')

逐行代码分析#

这一段代码的目的是创建一个名为 data.yaml 的配置文件，通常用于YOLO等深度学习模型的数据配置。我们来逐步分析这段代码的结构和含义。

代码解析#

1
with open('yolo_seg_dataset/data.yaml', 'w') as up:

功能: 使用 with open(...) as ...: 语句打开（或创建）一个名为 data.yaml 的文件，并以写入模式（'w'）打开。up 是一个文件对象，用于后续的写入操作。
上下文管理: 使用 with 语句可以确保文件在操作完成后自动关闭，避免文件未关闭导致的资源泄漏。

2. ==获取数据根路径==#

1
data_root = os.path.abspath('yolo_seg_dataset/')

功能: os.path.abspath(...) 返回给定路径的==绝对路径==。在这里，它将 'yolo_seg_dataset/' 转换为绝对路径并存储在 data_root 变量中。
示例: 如果当前工作目录是 /home/user/projects，那么 data_root 的值将是 /home/user/projects/yolo_seg_dataset。

3. 写入内容到文件#

1
up.write(f'''
2
path: {data_root}
3
train: train
4
val: valid
5

6
names:
7
    0: alter
8
''')

功能: 使用 write(...) 方法将格式化的字符串写入到 data.yaml 文件中。字符串的内容使用了多行字符串的语法（即用三个单引号包裹的字符串）。
内容解释:
- path: {data_root}: 写入数据集根路径的==绝对路径==。
- train: train: 指定训练数据的子目录名（==相对路径==）。
- val: valid: 指定验证数据的子目录名（==相对路径==）。
- names:: 这是一个字典，用于==映射类别ID到类别名称==。在这里，0 映射到类别名称 alter。

完整内容示例#

假设 data_root 的绝对路径为 /home/user/projects/yolo_seg_dataset，最终写入 data.yaml 文件的内容将类似于：

1
path: /home/user/projects/yolo_seg_dataset
2
train: train
3
val: valid
4

5
names:
6
    0: alter

总结#

这段代码生成了一个用于YOLO数据集配置的 data.yaml 文件，包含了数据集的根路径、训练和验证集的目录，以及类别的映射信息。该配置文件通常用于训练模型，帮助模型了解数据集的结构和类别定义。

步骤三：训练YOLO分割模型#

1
from ultralytics import YOLO
2

3
model = YOLO("./yolov8n-seg.pt")
4
results = model.train(data="./yolo_seg_dataset/data.yaml", epochs=10, imgsz=640)

逐行代码分析#

以下是对代码的逐行分析：

1
from ultralytics import YOLO

这行代码导入了 ultralytics 库中的 YOLO 类。
ultralytics 是一个用于目标检测的库，提供了易于使用的接口来训练和推理 YOLO 模型，尤其是 YOLOv8 模型。
YOLO 类是用于创建并管理 YOLO 模型的类，包括加载预训练模型、训练模型和进行推理。

1
model = YOLO("./yolov8n-seg.pt")

这行代码使用 YOLO 类创建了一个 model 实例。
YOLO("./yolov8n-seg.pt") 加载一个预训练的 YOLOv8 模型，该模型文件是 yolov8n-seg.pt。这是 YOLOv8 模型的小型版本（n 代表 nano纳米），同时具有分割功能（-seg 代表分割任务）。
通过这种加载方式，可以直接基于预训练模型进行进一步训练或推理。

1
results = model.train(data="./yolo_seg_dataset/data.yaml", epochs=10, imgsz=640)

model.train() 是 YOLO 模型的训练方法。
data="./yolo_seg_dataset/data.yaml" 指定了用于训练的数据集配置文件。data.yaml 文件通常包含训练集、验证集的路径，以及类别名称等信息。
epochs=10 指定模型要进行 10 个==训练周期==（epochs）。每个周期意味着模型将遍历完整的训练数据集一次。
imgsz=640 设置了输入图像的尺寸为 640 像素。YOLO 模型会将训练数据的图像调整到 640x640 的尺寸进行训练。

训练完成后，results 会包含训练过程中的结果和性能指标（如损失值、准确度等），这些结果可以用于评估模型的训练效果。

总结#

这段代码从 ultralytics 库中导入 YOLO 模型，加载了一个 YOLOv8 分割模型，并基于指定的数据集文件进行 10 个周期的训练，使用了 640x640 的图像输入尺寸。

步骤四：预测测试集#

1
from ultralytics import YOLO
2
import glob
3
from tqdm import tqdm
4

5
model = YOLO("./runs/segment/train6/weights/best.pt")
6
test_imgs = glob.glob('./test_set_A_rename/*/*')

1
Polygon = []
2
for path in tqdm(test_imgs[:]):
3
    results = model(path, verbose=False)
4
    result = results[0]
5
    if result.masks is None:
6
        Polygon.append([])
7
    else:
8
        Polygon.append([mask.astype(int).tolist() for mask in result.masks.xy])
9

10
import pandas as pd
11
submit = pd.DataFrame({
12
    'Path': [x.split('/')[-1] for x in test_imgs[:]],
13
    'Polygon': Polygon
14
})
15
submit.to_csv('track2_submit.csv', index=None)

展开收起

逐行分析代码#

这段代码使用预训练的YOLO模型来处理图像集，并将结果保存到CSV文件中。下面是逐行的分析：

1
from ultralytics import YOLO
2
import glob
3
from tqdm import tqdm

from ultralytics import YOLO: 从 ultralytics 库中导入 YOLO 类，这个类用于加载并使用预训练的 YOLO 模型进行推理和处理图像。
import glob: glob 模块用于文件操作，它可以根据特定的模式匹配文件路径。
from tqdm import tqdm: tqdm 模块用于显示进度条，常用于长时间运行的循环或任务中，帮助可视化处理进度。

1
model = YOLO("./runs/segment/train6/weights/best.pt")

这行代码加载了一个训练好的YOLO模型，权重文件位于 ./runs/segment/train6/weights/best.pt。这个模型是预训练的权重，专门用于图像分割任务。

1
test_imgs = glob.glob('./test_set_A_rename/*/*')

使用 glob.glob() 函数获取所有位于 ./test_set_A_rename/ 路径下的图像文件。
'*/*' 匹配所有子目录中的文件路径，因此它会抓取该目录下所有的图像路径，并存储在 test_imgs 列表中。

1
Polygon = []
2
for path in tqdm(test_imgs[:]):
3
    results = model(path, verbose=False)
4
    result = results[0]

Polygon = []: 初始化一个空列表 Polygon，用于存储每张图片的分割结果。
for path in tqdm(test_imgs[:]):: 通过 tqdm 包裹循环，遍历 test_imgs 中的每个图像路径，并显示进度条。
results = model(path, verbose=False): 调用模型对当前图片（path）进行推理，得到分割结果。verbose=False 表示不打印详细信息。
result = results[0]: YOLO 返回的结果可能包含多张图片（批处理），这里仅取第一个结果（当前处理的图片）。

1
if result.masks is None:
2
    Polygon.append([])
3
else:
4
    Polygon.append([mask.astype(int).tolist() for mask in result.masks.xy])

if result.masks is None:: 检查结果是否包含分割的掩码（masks）。如果没有分割掩码（即 result.masks 为 None），则向 Polygon 列表中添加一个空列表。
Polygon.append([mask.astype(int).tolist() for mask in result.masks.xy]): 如果存在分割掩码，将掩码的边界坐标（result.masks.xy）转换为整数并存储为 Python 列表的形式，然后将其添加到 Polygon 列表中。

==掩码（Mask）==在计算机视觉中是一个非常重要的概念，它通常用于表示图像中的特定区域。掩码的作用是突出或分离出图像中的某些部分（例如物体、背景等），便于后续的处理。掩码通常是一个与原始图像尺寸相同的二值化矩阵，每个像素点要么是 1（代表属于目标区域），要么是 0（代表不属于目标区域）。

在你的代码中，掩码（mask）与图像分割任务相关。模型返回的 mask 描述的是在图像中哪一部分属于分割出的对象。这些掩码可以是二值化的矩阵，也可以是其对应的轮廓坐标（多边形）。

1
import pandas as pd
2
submit = pd.DataFrame({
3
    'Path': [x.split('/')[-1] for x in test_imgs[:]],
4
    'Polygon': Polygon
5
})
6
submit.to_csv('track2_submit.csv', index=None)

import pandas as pd: 导入 pandas 库，用于处理数据并生成 CSV 文件。
submit = pd.DataFrame({...}): 创建一个 pandas 数据框 submit，包含两列：
- 'Path': 存储每张图像的文件名（通过 x.split('/')[-1] 从路径中提取文件名）。
- 'Polygon': 存储每张图像的分割结果（存储在 Polygon 列表中）。
submit.to_csv('track2_submit.csv', index=None): 将 submit 数据框保存为一个名为 track2_submit.csv 的 CSV 文件，index=None 表示不保存行索引。

总结#

这段代码使用YOLO模型处理一批图像，提取图像中的分割掩码边界（多边形），并将这些结果存储到一个CSV文件中。
tqdm 用来展示处理进度，pandas 则用来生成最终的提交文件（track2_submit.csv）。

【lagent】agent搭建

Wed, 18 Sep 2024 00:00:00 GMT

启动webui服务#

==使用lmdeploy启动一个api_server==

1
conda activate agent_camp3
2
lmdeploy serve api_server /share/new_models/Shanghai_AI_Laboratory/internlm2_5-7b-chat --model-name internlm2_5-7b-chat

==另开一个终端==，使用stremlit启动agent_web应用

1
cd /root/agent_camp3/lagent
2
conda activate agent_camp3
3
streamlit run examples/internlm2_agent_web_demo.py

==本地powershell建立ssh连接，进行端口映射==

Q&A#

遇到的问题：#

1
ModuleNotFoundError: No module named 'griffe.enumerations

解决方法：#

1
Due to griffe's recent 1.x release, the `griffe.enumerations` module has been removed, resulting in a break change, which can be resolved by
2
`pip install griffe==0.48`.

修改模型名称以及模型IP地址#

==启动streamlit的web应用如下==：

==修改红框内的内容==

==终端的反馈==：

PS:很是可惜，没有找到我想要的内容[1706.03762] Attention Is All You Need (arxiv.org)

自定义工具#

==进入lagent_web_demo的py文件中==

==添加&修改代码：==

1
from lagent.actions import ActionExecutor, ArxivSearch, IPythonInterpreter
2
+ from lagent.actions.magicmaker import MagicMaker
3
from lagent.agents.internlm2_agent import INTERPRETER_CN, META_CN, PLUGIN_CN, Internlm2Agent, Internlm2Protocol
4

5
...
6
        action_list = [
7
            ArxivSearch(),
8
+             MagicMaker(),
9
        ]

==重新启动agent_web服务==

使用MagicMaker工具绘画

==Prompt==：帮我画一个微笑的女孩，穿着校服在学校的走廊上，阳光照耀在她身上

==可以看到对于用户输入的提示词，有自动进行填充完善==

【评测】opencompass-司南

Wed, 04 Sep 2024 00:00:00 GMT

参考文档#

Tutorial/docs/L1/OpenCompass at camp3 · InternLM/Tutorial (github.com)

任务内容#

任务复现过程#

列出所有跟 InternLM 及 C-Eval 相关的配置：

1
python tools/list_configs.py internlm ceval

==评测结束==

【RAG】使用Llamaindex框架部署InternLM2-1.8B

Wed, 04 Sep 2024 00:00:00 GMT

一、前置知识#

给模型注入新知识的方式：
- 内部方式：更新模型的权重，但训练代价较大。
- 外部方式：给模型注入额外的上下文或外部信息，不改变其权重。
RAG 工作原理：
- 将问题编码成向量，在向量数据库中找到最相关的文档块（top-k chunks）。
- 将知识源分割成小块，编码成向量并存储在向量数据库中。
- 将检索到的文档块与原始问题一起作为提示输入到 LLM 中，生成最终的回答。
RAG 效果比对：
- 由于 xtuner 是较新的框架，InternLM2-Chat-1.8B 训练数据库中未收录相关信息，使用 RAG 前问答均未给出准确答案，使用后能获得想要的答案。

二、环境、模型准备#

（一）配置基础环境#

在 Intern Studio 服务器上部署 LlamaIndex：
- 打开 Intern Studio 界面，点击 创建开发机 配置开发机系统。
- 填写 开发机名称 后，点击 选择镜像 使用 Cuda11.7-conda 镜像，在资源配置中选择 30% A100 * 1 的选项，立即创建开发机器。
- 进入开发机后，创建新的 conda 环境，命名为 llamaindex，运行以下命令：
Terminal window
```
1
conda create -n llamaindex python=3.10
2
conda env list
3
conda activate llamaindex
4
conda install pytorch==2.0.1 torchvision==0.15.2 torchaudio==2.0.2 pytorch-cuda=11.7 -c pytorch -c nvidia
5
pip install einops==0.7.0 protobuf==5.26.1
```
- 环境激活后，命令行左边会显示当前环境名称。

（二）安装 LlamaIndex#

安装 LlamaIndex 和相关的包：

Terminal window

1
conda activate llamaindex
2
pip install llama-index==0.10.38 llama-index-llms-huggingface==0.2.0 "transformers[torch]==4.41.1" "huggingface_hub[inference]==0.23.1" huggingface_hub==0.23.1 sentence-transformers==2.7.0 sentencepiece==0.2.0

（三）下载 Sentence Transformer 词嵌入模型#

新建一个 python 文件，贴入以下代码：

1
import os
2

3
# 设置环境变量
4
os.environ['HF_ENDPOINT'] = 'https://hf-mirror.com'
5

6
# 下载模型
7
os.system('huggingface-cli download --resume-download sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2 --local-dir /root/model/sentence-transformer')

在 /root/llamaindex_demo 目录下执行该脚本自动开始下载。

（四）下载 NLTK 相关资源#

使用以下命令下载 nltk 资源并解压到服务器上：

Terminal window

1
cd /root
2
git clone https://gitee.com/yzy0612/nltk_data.git --branch gh-pages
3
cd nltk_data
4
mv packages/* ./
5
cd tokenizers
6
unzip punkt.zip
7
cd ../taggers
8
unzip averaged_perceptron_tagger.zip

三、LlamaIndex HuggingFaceLLM#

运行以下指令，把 InternLM2 1.8B 软连接出来：

Terminal window

1
cd ~/model
2
ln -s /root/share/new_models/Shanghai_AI_Laboratory/internlm2-chat-1_8b/ ./

新建一个 python 文件，贴入以下代码：

1
from llama_index.llms.huggingface import HuggingFaceLLM
2
from llama_index.core.llms import ChatMessage
3

4
llm = HuggingFaceLLM(
5
    model_name="/root/model/internlm2-chat-1_8b",
6
    tokenizer_name="/root/model/internlm2-chat-1_8b",
7
    model_kwargs={"trust_remote_code": True},
8
    tokenizer_kwargs={"trust_remote_code": True}
9
)
10

11
rsp = llm.chat(messages=[ChatMessage(content="xtuner 是什么？")])
12
print(rsp)

运行以下命令：

Terminal window

1
conda activate llamaindex
2
cd ~/llamaindex_demo/
3
python llamaindex_internlm.py

结果回答效果并不好，不是想要的 xtuner。

四、LlamaIndex RAG#

安装 LlamaIndex 词嵌入向量依赖：

Terminal window

1
conda activate llamaindex
2
pip install llama-index-embeddings-huggingface==0.2.0 llama-index-embeddings-instructor==0.1.3

获取知识库：

Terminal window

1
cd ~/llamaindex_demo
2
mkdir data
3
cd data
4
git clone https://github.com/InternLM/xtuner.git
5
mv xtuner/README_zh-CN.md ./

新建一个 python 文件，贴入以下代码：

1
from llama_index.core import VectorStoreIndex, SimpleDirectoryReader, Settings
2
from llama_index.embeddings.huggingface import HuggingFaceEmbedding
3
from llama_index.llms.huggingface import HuggingFaceLLM
4

5
# 初始化一个 HuggingFaceEmbedding 对象，用于将文本转换为向量表示
6
embed_model = HuggingFaceEmbedding(
7
    model_name="/root/model/sentence-transformer"
8
)
9
Settings.embed_model = embed_model
10

11
llm = HuggingFaceLLM(
12
    model_name="/root/model/internlm2-chat-1_8b",
13
    tokenizer_name="/root/model/internlm2-chat-1_8b",
14
    model_kwargs={"trust_remote_code": True},
15
    tokenizer_kwargs={"trust_remote_code": True}
16
)
17
Settings.llm = llm
18

19
# 从指定目录读取所有文档，并加载数据到内存中
20
documents = SimpleDirectoryReader("/root/llamaindex_demo/data").load_data()
21
index = VectorStoreIndex.from_documents(documents)
22
query_engine = index.as_query_engine()
23
response = query_engine.query("xtuner 是什么?")
24

25
print(response)

展开收起

运行以下命令：

Terminal window

1
conda activate llamaindex
2
cd ~/llamaindex_demo/
3
python llamaindex_RAG.py

结果借助 RAG 技术后，能获得想要的答案。

五、LlamaIndex Web#

安装依赖：
Terminal window
```
1
pip install streamlit==1.36.0
```

新建一个 python 文件，贴入以下代码：

1
import streamlit as st
2
from llama_index.core import VectorStoreIndex, SimpleDirectoryReader, Settings
3
from llama_index.embeddings.huggingface import HuggingFaceEmbedding
4
from llama_index.llms.huggingface import HuggingFaceLLM
5

6
st.set_page_config(page_title="llama_index_demo", page_icon="🦜🔗")
7
st.title("llama_index_demo")
8

9
# 初始化模型
10
@st.cache_resource
11
def init_models():
12
    embed_model = HuggingFaceEmbedding(
13
        model_name="/root/model/sentence-transformer"
14
    )
15
    Settings.embed_model = embed_model
16

17
    llm = HuggingFaceLLM(
18
        model_name="/root/model/internlm2-chat-1_8b",
19
        tokenizer_name="/root/model/internlm2-chat-1_8b",
20
        model_kwargs={"trust_remote_code": True},
21
        tokenizer_kwargs={"trust_remote_code": True}
22
    )
23
    Settings.llm = llm
24

25
    documents = SimpleDirectoryReader("/root/llamaindex_demo/data").load_data()
26
    index = VectorStoreIndex.from_documents(documents)
27
    query_engine = index.as_query_engine()
28

29
    return query_engine
30

31
# 检查是否需要初始化模型
32
if 'query_engine' not in st.session_state:
33
    st.session_state['query_engine'] = init_models()
34

35
def greet2(question):
36
    response = st.session_state['query_engine'].query(question)
37
    return response

展开收起

Store LLM generated responses#

if “messages” not in st.session_state.keys(): st.session_state.messages = [{“role”: “assistant”, “content”: “你好，我是你的助手，有什么我可以帮助你的吗？”}]

Display or clear chat messages#

for message in st.session_state.messages: with st.chat_message(message[“role”]): st.write(message[“content”])

def clear_chat_history(): st.session_state.messages = [{“role”: “assistant”, “content”: “你好，我是你的助手，有什么我可以帮助你的吗？”}]

st.sidebar.button(‘Clear Chat History’, on_click=clear_chat_history)

Function for generating LLaMA2 response#

def generate_llama_response(question): response = greet2(question) return response

User-provided prompt#

if prompt := st.chat_input(“What’s on your mind?”): st.chat_message(“user”).write(prompt) with st.chat_message(“assistant”): message_placeholder = st.empty() response = generate_llama_response(prompt) message_placeholder.write(response) st.session_state.messages.append({“role”: “assistant”, “content”: response})

启动 Streamlit 服务：

Terminal window

1
cd ~/llamaindex_demo/
2
streamlit run llamaindex_streamlit.py

打开浏览器，访问 https://locahost:XXX。

六、总结#

本文介绍如何结合 LlamaIndex 和 InternLM2 部署 RAG，为大模型注入最新知识库，效果显著。

七、作业#

==RAG前==

==RAG后==

==使用Streamlit部署webui（使用RAG）==

【Fine-tuning】XTuner微调个人小助手

Wed, 04 Sep 2024 00:00:00 GMT

任务内容#

完成任务截图#

【Prompt Engineering】LangGPT结构化提示词编写

Tue, 03 Sep 2024 00:00:00 GMT

前言#

在日常使用大模型时，我发现它经常在数字比对这类基础问题上出错，并且输出结果很不严谨。为了解决这个问题，我尝试使用Prompt Engineering，并在网上找到了一个开源的「结构化提示词框架」— LangGPT，以下是我的使用过程记录。

实现步骤#

step0：前期准备

创建虚拟环境->激活虚拟环境->安装必要包文件
创建项目路径->进入项目
安装必要软件，如tmux

step1：模型部署模型下载->部署模型为OpenAI server->图形化界面调用 ‬⁠⁠⁠ step3：langgpt结构化提示词⁠‬编写⁠‍‬⁠‬‬‬‌‌‌‍‌‌ 偷懒大法：GPTS有LangGPT提示词专家，用大模型生成即可

tmux使用#

tmux可以在终端中创建终端，将进程维持在后台。

所以当我们下载模型，使用tmux在后台下载时，即便我们断开ssh连接，下载也不会中断。

step1：部署模型为OpenAI server

tmux常见命令#

1.创建窗口命令：

==PS：t表示target(目标)，用于指定会话、窗口或面板的名称==

Terminal window

1
tmux new -t <session_name>

PS：创建完成后，运行下面的命令进入新的命令窗口(==首次创建自动进入，之后需要连接==)：其中a 是 attach 的简写

Terminal window

1
tmux a -t <session_name>

2.查看当前 tmux 会话：

Terminal window

1
tmux ls

3.连接到特定的 tmux 会话：

Terminal window

1
tmux attach -t <session_name>

将 <session_name> 替换为你要连接的会话的实际名称或编号。

4.杀死整个 tmux 会话：

Terminal window

1
tmux kill-session -t <session_name>

5.退出tmux:

Ctrl+B进入tmux的控制模式，然后按d退出窗口连接

模型部署#

进入命令窗口后，需要在新窗口中再次激活环境，命令参考0.1节。然后，使用LMDeploy进行部署，参考如下命令：

使用LMDeploy进行部署，参考如下命令：

Terminal window

1
CUDA_VISIBLE_DEVICES=0 lmdeploy serve api_server /share/new_models/Shanghai_AI_Laboratory/internlm2-chat-1_8b --server-port 23333 --api-keys internlm2

部署成功后，可以利用如下脚本调用部署的InternLM2-chat-1_8b模型并测试是否部署成功。

1
from openai import OpenAI
2

3
client = OpenAI(
4
    api_key = "internlm2",
5
    base_url = "http://0.0.0.0:23333/v1"
6
)
7

8
response = client.chat.completions.create(
9
    model=client.models.list().data[0].id,
10
    messages=[
11
        {"role": "system", "content": "请介绍一下你自己"}
12
    ]
13
)
14

15
print(response.choices[0].message.content)

展开收起

服务启动完成后，可以按Ctrl+B进入tmux的控制模式，然后按D退出窗口连接，更多操作参考。

作业：#

基础任务 (完成此任务即完成闯关)：

背景问题：近期相关研究发现，LLM在对比浮点数字时表现不佳，经验证，internlm2-chat-1.8b (internlm2-chat-7b)也存在这一问题，例如认为13.8<13.11。
任务要求：利用LangGPT优化提示词，使LLM输出正确结果。完成一次并提交截图即可

使用GPTS中LangGPT提示词专家，配合我们的需求生成LangGPT结构化提示词

==生成结果如下==：

1
# Role: 数学助手
2

3
## Profile
4
- author: LangGPT
5
- version: 1.0
6
- language: 中文
7
- description: 一个能够进行基本数学加减法运算，并能够比较两个数字大小的助手。
8

9
## Skills
10
1. 能够进行基本的数学加法和减法运算。
11
2. 能够比较两个数字的大小，并给出相应的判断。
12
3. 能够理解用户输入的简单数学表达式或问题描述。
13

14
## Rules
15
1. 用户输入可以是任意两个数字或一个包含加法、减法的表达式。
16
2. 当输入两个数字时，助手应比较它们的大小，并返回结果。
17
3. 当输入一个加法或减法表达式时，助手应计算出结果并返回。
18
4. 如果用户输入有误或不符合数学表达式规则，助手应给出提示并要求重新输入。
19

20
## Workflows
21
1. 接收用户输入的数字或数学表达式。
22
2. 判断输入的类型（两个数字或数学表达式）。
23
3. 如果是两个数字，执行大小比较，并返回结果。
24
4. 如果是数学表达式，进行加法或减法计算，返回结果。
25
5. 如果输入不符合预期格式，返回错误提示，要求用户重新输入。
26

27
## Init
28
1. 向用户介绍助手的功能和使用方法。
29
2. 提示用户可以输入两个数字进行比较，或输入一个加法、减法表达式进行计算。

展开收起

==加入系统提示词前：== PS：估计InternLM2-chat-1_8b版本太久远了，所以回答不出来🤔

==加入系统提示词后：== PS：效果明显变好了😋

Reference：#

1.LangGPT社区：‌‌‬⁠⁠⁠‌⁠‬‌⁠‍‬⁠‬‬‬‌‌‌‍‌‌‬⁠LangGPT结构化提示词 - 飞书云文档 2.浦语开源文档书生浦语-浦语提示词工程实践 3.文档：系统论述文章：构建高性能 Prompt 之路——结构化 Prompt

8G显存玩转书生大模型Demo

Tue, 20 Aug 2024 00:00:00 GMT

环境配置#

1
# 创建环境
2
conda create -n demo python=3.10 -y
3
# 激活环境
4
conda activate demo
5
# 安装 torch
6
conda install pytorch==2.1.2 torchvision==0.16.2 torchaudio==2.1.2 pytorch-cuda=12.1 -c pytorch -c nvidia -y
7
# 安装其他依赖
8
pip install transformers==4.38
9
pip install sentencepiece==0.1.99
10
pip install einops==0.8.0
11
pip install protobuf==5.27.2
12
pip install accelerate==0.33.0
13
pip install streamlit==1.37.0

InternLM2-Chat-1.8B 模型部署#

一、用Cli Demo 部署#

1.创建demo文件夹，用于存放代码。并创建 cli_demo.py文件

1
mkdir -p /root/demo
2
touch /root/demo/cli_demo.py

其中cli_demo.py 的代码为：

1
import torch
2
from transformers import AutoTokenizer, AutoModelForCausalLM
3

4

5
model_name_or_path = "/root/share/new_models/Shanghai_AI_Laboratory/internlm2-chat-1_8b"
6

7
tokenizer = AutoTokenizer.from_pretrained(model_name_or_path, trust_remote_code=True, device_map='cuda:0')
8
model = AutoModelForCausalLM.from_pretrained(model_name_or_path, trust_remote_code=True, torch_dtype=torch.bfloat16, device_map='cuda:0')
9
model = model.eval()
10

11
system_prompt = """You are an AI assistant whose name is InternLM (书生·浦语).
12
- InternLM (书生·浦语) is a conversational language model that is developed by Shanghai AI Laboratory (上海人工智能实验室). It is designed to be helpful, honest, and harmless.
13
- InternLM (书生·浦语) can understand and communicate fluently in the language chosen by the user such as English and 中文.
14
"""
15

16
messages = [(system_prompt, '')]
17

18
print("=============Welcome to InternLM chatbot, type 'exit' to exit.=============")
19

20
while True:
21
    input_text = input("\nUser  >>> ")
22
    input_text = input_text.replace(' ', '')
23
    if input_text == "exit":
24
        break
25

26
    length = 0
27
    for response, _ in model.stream_chat(tokenizer, input_text, messages):
28
        if response is not None:
29
            print(response[length:], flush=True, end="")
30
            length = len(response)

展开收起

2.在终端执行python /root/demo/cli_demo.py命令启动Demo

3.使用 Cli Demo 完成 InternLM2-Chat-1.8B 模型的部署，并生成 300 字小故事

二、用Streamlit Web Demo 部署#

1.clone InternLM 的github仓库到本地：

Terminal window

1
cd /root/demo
2
git clone https://github.com/InternLM/Tutorial.git

2.启动Streamlit 服务：

Terminal window

1
cd /root/demo
2
streamlit run /root/demo/Tutorial/tools/streamlit_demo.py --server.address 127.0.0.1 --server.port 6006

3.在本地的 PowerShell 中输入以下命令，将端口映射到本地：

Terminal window

1
ssh -CNg -L 6006:127.0.0.1:6006 root@ssh.intern-ai.org.cn -p 你的 ssh 端口号

4.完成端口映射后，通过浏览器访问 http://localhost:6006 来启动我们的 Demo。

LMDeploy 部署#

一、InternLM-XComposer2-VL-1.8B 模型#

模型介绍：#

InternLM-XComposer2 是一款基于 InternLM2 的视觉语言大模型，其擅长自由形式的文本图像合成和理解。其主要特点包括：

自由形式的交错文本图像合成：InternLM-XComposer2 可以根据大纲、详细文本要求和参考图像等不同输入，生成连贯且上下文相关，具有交错图像和文本的文章，从而实现高度可定制的内容创建。
准确的视觉语言问题解决：InternLM-XComposer2 基于自由形式的指令准确地处理多样化和具有挑战性的视觉语言问答任务，在识别，感知，详细标签，视觉推理等方面表现出色。

部署步骤：#

1.激活环境并安装 LMDeploy 以及其他依赖。

Terminal window

1
conda activate demo
2
pip install lmdeploy[all]==0.5.1
3
pip install timm==1.0.7

2.使用 LMDeploy 启动一个与 InternLM-XComposer2-VL-1.8B 模型交互的 Gradio 服务。

Terminal window

1
lmdeploy serve gradio /share/new_models/Shanghai_AI_Laboratory/internlm-xcomposer2-vl-1_8b --cache-max-entry-count 0.1

3.若已关闭端口映射，重新输入以下代码即可:

1
ssh -CNg -L 6006:127.0.0.1:6006 root@ssh.intern-ai.org.cn -p 36558

通过浏览器访问 http://localhost:6006 来启动==InternLM-XComposer2-VL-1.8B==模型

输入图片并询问图片里有什么：

输出：

二、InternVL2-2B 模型#

模型介绍:#

InternVL2 是上海人工智能实验室推出的新一代视觉-语言多模态大模型，是首个综合性能媲美国际闭源商业模型的开源多模态大模型。InternVL2 系列从千亿大模型到端侧小模型全覆盖，通专融合，支持多种模态。

部署步骤：#

1.通过下面的命令来启动 InternVL2-2B 模型的 Gradio 服务:

Terminal window

1
conda activate demo
2
lmdeploy serve gradio /share/new_models/OpenGVLab/InternVL2-2B --cache-max-entry-count 0.1

2.若已关闭端口映射，重新输入以下代码即可:

1
ssh -CNg -L 6006:127.0.0.1:6006 root@ssh.intern-ai.org.cn -p 36558

通过浏览器访问 http://localhost:6006 来启动==InternVL2-2B==模型

输入图片并询问详细描述图片内容：

输出：

书生·浦语大模型全链路开源开放体系及其最新发展

Thu, 08 Aug 2024 00:00:00 GMT

博客：书生·浦语大模型全链路开源开放体系及其最新发展#

在现代人工智能技术的迅猛发展浪潮中，书生·浦语大模型全链路开源开放体系以其独特的优势和卓越的性能，在各个领域中不断取得突破性进展。本文将详细介绍该体系的发展历程、最新版本的特征、基于规则、模型和反馈的数据生成方法，以及mind search项目、开源数据提取工具和预训练框架、EXTINA的评测和部署、知识管理工具等各个方面的应用与优化策略。

书生·浦语大模型全链路开源开放体系的历程及最新版本的特征#

书生·浦语大模型开源开放体系在多个方面表现出色，包括数据收集整理、模型训练、微调、评测和搜索引擎AI应用的部署等方面。最新版本书生·浦语大模型2.5在推理能力和短期记忆等方面有质的飞跃，并开放了label LLM项目，方便标注数据。此外，视频还介绍了模型的性能天梯和应用前景。

书生浦语大模型开源开放体系
InputLM2.5性能飞跃
迭代发展过程中的数据驱动模型性能

基于规则、模型和反馈的数据生成方法，以及如何使用开源项目进行标注和推理#

反映模型的数据生成方法在模型优化和训练过程中至关重要，以下是一些关键方法的介绍：

基于模型的反馈数据生成方法：包括相似度对齐和基于反馈的强化训练。
大海捞针实验：介绍模型的推理能力和大海捞针实验，模型在处理稀长背景知识的表现。
问题匹配分块：介绍问题匹配分块的方法，可以用于语言模型的索引和问题理解。

mind search项目#

mind search项目展示了其在语言模型、预训练模型、微调框架、部署工具等方面的强大功能和应用潜力。

Mindsearch项目和书生普与开源模型谱系
部署工具和评测工具
应用方面的工具和框架

开源数据提取工具Minor U和预训练框架XTNER#

Minor U和XTNER提供了无缝衔接和数据格式兼容性的功能，极大地加速了模型的训练和优化过程。

智能体框架和开源工具无缝衔接
微调框架和数据格式兼容性
使用XTNER进行微调的方法和流程

EXTINA的评测和部署#

EXTINA通过微调和Open Compass评测模型，以及lm deploy的推理性能对比，构建了智能体框架建设方案。

使用EXTINA微调和Open Compass评测模型
lm deploy模型部署框架和智能体框架
基于AI的搜索引擎和知识插件

知识管理工具笞香豆的企业级应用#

知识管理工具笞香豆通过可视化、强生和知识图谱生成，支持搜索和思考过程的展示，推动了开源生态系统的完善和实践营的创新发展。

思维可视化：通过搜索和思考1900年和1924年的相关信息，展示了模拟人脑思维逻辑的可视化过程。
支持检索增强生成和知识图谱：理解群体行为。
赋能创新：通过开源生态实践营，持续以高质量的开源赋能创新。

在人工智能的快速发展中，书生·浦语大模型全链路开源开放体系无疑是一颗璀璨的明珠。它不仅在技术上不断推陈出新，在应用上也不断拓展，为各行各业带来了无限的可能。期待未来它能为更多领域提供支持，推动社会的智能化发展。

🍉Book-2章-模型评估与选择

Thu, 16 May 2024 00:00:00 GMT

术语名词#

1.泛化误差与经验误差

泛化误差：在“未来”样本上的误差
经验误差：在训练集上的误差，亦称“训练误差”

训练集样本数越接近数据集数量，经验误差就越小。但是经验误差越小，模型效果就越好吗？

请注意，我们是为了得到泛化能力强的模型，而经验误差≠泛化误差

经验误差很小，会使模型学习到训练样本中的许多无用特征，导致泛化能力变弱 我们称其为过拟合(overfitting)

而与之相对的概念，我们称为欠拟合(underfitting)，其表示的就是模型没有很好的学习到训练样本上的特征，从而也导致泛化能力变弱

2.过拟合与欠拟合

过拟合：模型在训练数据上表现得过于复杂，以至于在未见过的数据上表现不佳。欠拟合：模型在训练数据上表现得过于简单，无法捕捉到数据的内在结构和模式。

出现原因： 1.出现欠拟合的情况，一般是由于样本特征少，模型复杂度低等

2.出现过拟合的情况，一般是由于样本数量少、噪声多，模型复杂度过高等

经验误差就是训练程度的体现，经验误差越小则训练程度越强所以现在，我们可以得出训练程度不能过大也不能过小的结论

那我们能找到一个最佳方案得出最佳的训练程度吗🤔

答案是--------------->不能🙅‍

原因是：对于千禧年七大数学问题之——“P=NP”问题，只要我们相信”P≠NP”，就无法找出最优解

但是我们依然有相应的解决方法，用于欠拟合与过拟合的问题此处的解决方法我们留待以后解决…

好了，回归本章主题—模型评估与选择

对于模型的选择，我们有三个关键问题：

如何获得测试集？------>评估方法
如何评价性能优劣？------>性能度量
如何判断模型实质差别------>比较检验

1.评估方法#

因为我们无法得知未来数据的输出标记故而需要得到测试集用来评估模型

而测试集有多种划分方法，这里我们给出以下三种

1.1 留出法(hold-out)：#

将数据集直接划分为训练集和测试集

留出法：对数据集的划分方法会影响模型结果；训练集和测试集的数据分布必须保持一致；测试集过大会使模型拟合效果变差，太小会使得测试估计偏小；有一些数据可能从未被训练过

总结：

保证数据分布一致性（比如分层取样）
多次重复划分 (例如: 100次随机划分)
测试集不能太大或太小（例如：1/5~1/3，其实二八分偏多）
可能遗漏数据（随机划分没取到该数据进行训练）

1.2 交叉验证法#

对于 留出法出现可能遗漏数据（随机划分没取到该数据进行训练）的问题

我们引入新的划分方法 k-折交叉验证法可以有效解决该问题

以该图为例：

首先将数据集D随机划分为10个子集，进行十次操作，每一次取其中1个子集为测试集，其余为训练集（实际也可以选取多个子集为测试集）将结果做平均处理

而对于再划分子集的阶段，将测试集中只留有一个数据的方法叫做留一法 留一法，使得训练集极大地逼近了真实模型，但是却让测试误差变得很大

优缺点：从而我们能得出，尽管交叉检验法保证了所有的数据均被训练，但仍然存在受限于样本大小的问题；

并且对于较大的k值，会使得计算成本显著增加；

而且对于子集的划分，仍然是一个难题，如果测试集和训练集之间的划分不够随机或不够独立，可能会导致数据泄露，影响模型评估的准确性。

1.3 自助法#

“自助法”(bootstrapping) 基于==放回取样== 亦称“可重复采样”

故其可以使最终训练集的样本个数=数据集的样本个数，我们记数据集的样本个数为m，则由洛必达法则可得出未被取出即未进行训练的样本，我们称为==包外估计==(out-of-bag estimate)的占比为： lim⁡m→∞(1−1m)m→1e≈0.368 \lim _ { m \rightarrow \infty } ( 1 - \frac { 1 } { m } ) ^ { m } \rightarrow \frac { 1 } { e } \approx 0 . 3 6 8limm→∞(1−m1)m→e1≈0.368 我们将其作为训练集即可

优缺点：

优点：自助法在数据集较小、难以有效划分训练/测试集时很有用，自助法能从初始数据集中产生多个不同的训练集,这对==集成学习==等方法有很大的好处。

缺点：自助法产生的数据集改变了初始数据集的分布，这会引入估计偏差。但是通过增加数据划分的次数，就可以缓解该影响。

1.4 调参与验证集#

在模型评估与选择的过程中，我们既要选择学习算法，还要对算法的参数进行设定

训练过程中的参数分为两种：

算法参数：亦称“超参数”，由人工设定
模型参数：由训练集训练而成

1.5 重新训练#

重新训练：在调整和优化模型之后，可能需要使用整个数据集（包括之前划分的训练集和测试集）重新训练模型，以利用所有可用数据来提高模型的性能。

故之所以划分训练集和测试集，仅仅是为了选定==算法==的种类和参数当我们确定使用该算法后，我们应将整个数据集放入该算法进行训练，从而得到模型的参数

2.性能度量#

2.1 错误率和精度#

错误率定义：

E(f;D)=1m∑i=1mI(f(xi)≠yi)E(f;D)=\frac{1}{m}\sum_{i=1}^{m}\mathbb{I}\left(f\left(\boldsymbol{x}_{i}\right)\neq y_{i}\right)E(f;D)=m1i=1∑mI(f(xi)=yi)

精度定义：

acc⁡(f;D)=1m∑i=1mI(f(xi)=yi)=1−E(f;D)\begin{aligned}\operatorname{acc}(f;D)&=\quad\frac{1}{m}\sum_{i=1}^{m}\mathbb{I}\left(f\left(\boldsymbol{x}_{i}\right)=y_{i}\right)\\&=\quad1-E(f;D) \end{aligned}acc(f;D)=m1i=1∑mI(f(xi)=yi)=1−E(f;D)

然而对于不同的任务需求，仅仅用错误率和精度是不够的，故引出查准率、查全率、F1的概念

2.2 查准率、查全率、F1#

二分类任务：#

1
现有一瓜田含10000个瓜，其中有100个好瓜，利用学习器挑瓜
2

3
查准率：即准确率（precision），如挑出瓜中好瓜的比例
4

5
查全率：即召回率（recall），如所有好瓜中被挑出的比例
6

7
F1-score：即查准率与查全率的调和平均

在选瓜任务中我们的目标是：

在挑出来的瓜中尽可能都是好瓜
瓜田中的好瓜尽可能多地被挑出来很直观的可以感受到查全率越大(如挑出越多的瓜，好瓜被挑出的比例也就越大），查准率就会越低

==混淆矩阵==：

其中查准率P和查全率R的定义为：

P=TPTP+FPP=\frac{TP}{TP+FP}P=TP+FPTPR=TPTP+FNR=\frac{TP}{TP+FN}R=TP+FNTP

F1即综合考虑两者效果:

1F1=12⋅(1P+1R)\frac1{F1}=\frac12\cdot\left(\frac1P+\frac1R\right)F11=21⋅(P1+R1)

多分类任务：#

2.3 ROC与AUC#

3.比较检验#

🍉Book-3章-线性模型

Thu, 16 May 2024 00:00:00 GMT

所需数学知识#

求偏导
矩阵求导
求逆矩阵

名词解释#

1.序关系

1
有序：属性之间可进行相对比较（如大、中、小）
2
无序：属性之间不可进行相对比较（如南瓜、西瓜、冬瓜）

2.符号arg与s.t.

1
arg：即argument（参数），用于表示求出指定函数时的**参数取值**
2
  例如：
3
  arg min 就是使后面这个式子达到最小值时的 变量的取值
4
  arg max 就是使后面这个式子达到最大值时的 变量的取值
5

6
s.t.：即subject to，意思是受限于...，后面紧跟约束条件

3.闭式解

1
也叫做 解析解，
2
闭式解就是一些严格的公式,给出任意的自变量就可以求出其因变量,也就是问题的解
3
南瓜书中说闭式解是指可以通过具体的表达式解出待解参数

模型介绍#

表示形式#

对于拥有d个属性的示例 x，表示为：x=(x1;x2;…;xd)x = ( x _ { 1 } ; x _ { 2 } ; \ldots ; x _ { d } )x=(x1;x2;…;xd) 其中xix_ixi表示第i个属性的属性值 而我们将各属性的线性组合作为线性模型，表示为： f(x)=w1x1+w2x2+…+wdxd+bf ( x ) = w _ { 1 } x _ { 1 } + w _ { 2 } x _ { 2 } + \ldots + w _ { d } x _ { d } + bf(x)=w1x1+w2x2+…+wdxd+b

也可写成向量形式 $$ f ( x ) = w ^ { T } x + b ,$$ 其中$w$和$x$均为列向量，其中$w$可以理解成为不同属性的**偏好**而赋予的**权重** 故线性模型具有很强的**可解释性**

模型优点#

简单（模型表示、数学公式简单）
基本（通过引入层级结构或高维映射可以得到许多非线性模型）
可理解性好（通过权重可以看出对属性的偏好）

属性数值化#

总结：==离散属性的处理：若有“序”(order)，则连续化；否则，转化为 𝑘维向量==

对于线性模型的求解，我们首先需要明确参数的输入和求解两个部分

我们知道模型的输入为各个示例 xix_ixi，其中的xix_ixi由d个属性组成，而我们用d个属性值表示一个具体的示例xix_ixi作为输入

这时我们会发现我们需要注意属性值的数据类型 于是这里我们把属性分为两类

连续属性
离散属性
- 有序的离散属性
- 无序的离散属性

对于有序的属性，我们用相对值表示属性值，如大、中、小分别用1，0.5，0来表示

对于无序的属性，我们用0/1表示属性值，我们记改属性有m种属性值，则一个属性值需要m维列向量进行表示。

比如对于属性瓜的类别，有西瓜，南瓜，冬瓜三种属性值，则表示为 x1=(1;0;0),x2=(0;1;0),x3=(0;0;1)x _ { 1 } = ( 1 ; 0 ; 0 ) , x _ { 2 } = ( 0 ; 1 ; 0 ) , x _ { 3 } = ( 0 ; 0 ; 1 )x1=(1;0;0),x2=(0;1;0),x3=(0;0;1) 这里表示示例x1,x2,x3x_1,x_2,x_3x1,x2,x3分别为西瓜，南瓜，冬瓜

对于==回归==，==二分类==，==多分类==任务，我们给出不同的线性模型

1.png

回归任务#

最小二乘法#

在第二章中我们知道均方误差是回归任务的常见性能度量 均方误差本身也具有很好的几何意义，对于欧氏距离

定义：基于均方误差最小化进行模型求解，使得样本到直线的欧式距离之和最小

数学知识：涉及求偏导数

1.一元线性回归#

1.假设方程 $$ f\left(x_{i}\right)=w x_{i}+b, 使得 f\left(x_{i}\right) \simeq y_{i}. $$2.均方误差最小化时的w和b的值 $$ \begin{aligned}\left(w^{*}, b^{*}\right) & =\underset{(w, b)}{\arg \min } \sum_{i=1}^{m}\left(f\left(x_{i}\right)-y_{i}\right)^{2} \\ & =\underset{(w, b)}{\arg \min } \sum_{i=1}^{m}\left(y_{i}-w x_{i}-b\right)^{2} .\end{aligned} $$3.均方误差对𝑤与𝑏求偏导 $$ \begin{array}{l}\frac{\partial E_{(w, b)}}{\partial w}=2\left(w \sum_{i=1}^{m} x_{i}^{2}-\sum_{i=1}^{m}\left(y_{i}-b\right) x_{i}\right), \\ \frac{\partial E_{(w, b)}}{\partial b}=2\left(m b-\sum_{i=1}^{m}\left(y_{i}-w x_{i}\right)\right),\end{array} $$ 此处$E_{(w, b)}$是是关于w和b的凸函数 **注意**：此处凸函数定义与数学分析中相同，与高等数学中相反4.令偏导为0，得到闭式解，解得w和b $$ \begin{array}{c}w=\frac{\sum_{i=1}^{m} y_{i}\left(x_{i}-\bar{x}\right)}{\sum_{i=1}^{m} x_{i}^{2}-\frac{1}{m}\left(\sum_{i=1}^{m} x_{i}\right)^{2}}, \\ b=\frac{1}{m} \sum_{i=1}^{m}\left(y_{i}-w x_{i}\right)\end{array} $$

2.多元线性回归#

额外数学知识:

==矩阵求导==

基于本人数学系所教授的高等代数中无此内容，故认为需要额外补充学习

详见西瓜书附录P400 A.2 导数

1.假设方程 $$ f\left(\boldsymbol{x}_{i}\right)=\boldsymbol{w}^{\mathrm{T}} \boldsymbol{x}_{i}+b, 使得 f\left(\boldsymbol{x}_{i}\right) \simeq y_{i}, $$ 2.为便于讨论，把w和b吸收入向量形式，数据集表示为X=(x11x12…x1d1x21x22…x2d1⋮⋮⋱⋮⋮xm1xm2…xmd1)=(x1T1x2T1⋮⋮xmT1)\mathbf{X}=\left(\begin{array}{ccccc}x_{11} & x_{12} & \ldots & x_{1 d} & 1 \\ x_{21} & x_{22} & \ldots & x_{2 d} & 1 \\ \vdots & \vdots & \ddots & \vdots & \vdots \\ x_{m 1} & x_{m 2} & \ldots & x_{m d} & 1\end{array}\right)=\left(\begin{array}{cc}\boldsymbol{x}_{1}^{\mathrm{T}} & 1 \\ \boldsymbol{x}_{2}^{\mathrm{T}} & 1 \\ \vdots & \vdots \\ \boldsymbol{x}_{m}^{\mathrm{T}} & 1\end{array}\right)X=x11x21⋮xm1x12x22⋮xm2……⋱…x1dx2d⋮xmd11⋮1=x1Tx2T⋮xmT11⋮1

示例中的属性值为列向量，同时将标记写成向量形式 y=(y1;y2;…;ym)y = ( y _ { 1 } ; y _ { 2 } ; \ldots ; y _ { m } )y=(y1;y2;…;ym)

注意：此处将f(xi)=wTxi+bf\left(\boldsymbol{x}_{i}\right)=\boldsymbol{w}^{\mathrm{T}} \boldsymbol{x}_{i}+bf(xi)=wTxi+b中的 bbb 拆成b*1的形式，用xxx吸收111，用www吸收bbb变成w^\hat{\boldsymbol{w}}w^

2.png

[图片源于周志华老师]

3.解得w $$ \hat{\boldsymbol{w}}^{*}=\left(\mathbf{X}^{\mathrm{T}} \mathbf{X}\right)^{-1} \mathbf{X}^{\mathrm{T}} \boldsymbol{y} $$4.最终解得模型为： $$ f\left(\hat{\boldsymbol{x}}_{i}\right)=\hat{\boldsymbol{x}}_{i}^{\mathrm{T}}\left(\mathbf{X}^{\mathrm{T}} \mathbf{X}\right)^{-1} \mathbf{X}^{\mathrm{T}} \boldsymbol{y}. $$

1.若XTX满秩或正定,则w∗=(XTX)−1XTy1.若 X ^ { T } X 满秩或正定 , 则 w ^ { * } = ( X ^ { T } X ) ^ { - 1 } X ^ { T } y1.若XTX满秩或正定,则w∗=(XTX)−1XTy 2.若XTX不满秩,则可解出多个w^2.若X ^ { T } X 不满秩 , 则可解出多个 \widehat { w }2.若XTX不满秩,则可解出多个w 此时需求助于归纳偏好，常见做法是引入 正则化项（详见6.4节，11.4节）

通过在损失函数中添加惩罚项来限制模型的复杂度，常见的正则化方法包括岭回归（Ridge Regression）、Lasso回归和弹性网（Elastic Net）

PS：w^∗\widehat { w } ^ { * }w∗转换成二次型矩阵相乘还挺有意思的，推导详见南瓜书P35，P36

3.广义线性模型(GLM)#

令预测值逼近 y 的衍生物

对数线性模型#

假设我们认为示例所对应的输出标记是在指数尺度上变化，那就可将输出标记的对数作为线性模型逼近的目标

个人理解：

其实就是我们在原样本中，通过数值或者散点图，观察到输出标记在指数尺度上变化，故很难直接用一条直线拟合输出标记，因为标记值本身为非线性增长。

而对在指数尺度上变化的输出标记取对数后，就可以将输出标记映射到线性尺度上变化，故易于用直线拟合

y=wTx+by = w ^ { T } x + by=wTx+b

将输出标记 y 取对数转变为形式上的线性回归方程

ln⁡y=wTx+b\ln y = w ^ { T } x + blny=wTx+b

实际上是在试图让ewTx+be ^ { w ^T x} + bewTx+b逼近y
这里的对数函数起到了将线性回归模型的预测值与真实标记联系起来的作用
但实质上已是在求取输入空间到输出空间的非线性函数映射

我们知道，对数线性模型是使用对数函数将输出标记进行映射

那么如果我们选取不同的函数对输出标记进行映射，就能将一个非线性变化的样本用线性模型进行拟合了。

而此时问题就转变为映射函数的寻找了，需要找到一个合适的映射函数，将原来的标记值数据形态映射成线性的🤔

这里就涉及到模型的优化了，找到映射函数得到新的线性模型，并在某一性能度量下进行比较，结合需求选择模型。

而由此我们引出了广义线性模型（Generalized Linear Model）的定义：

y=g−1(wTx+b) y = g ^ { - 1 } ( w ^ { T } x + b )y=g−1(wTx+b) 其中g(⋅)g ( \cdot )g(⋅)为连续且充分光滑的单调可微函数，称为联系函数(link function)

广义线性模型的参数估计常通过加权最小二乘法或极大似然法进行

显然，对数线性回归是广义线性模型在 g(⋅)g ( \cdot )g(⋅)=ln(⋅)ln ( \cdot )ln(⋅)时的特例显然，一元线性回归也是如此

分类任务#

引导#

在先前的文章：西瓜书-第3章-线性模型 (Part 1) 中我们介绍了 一元线性回归、多元线性回归、广义线性回归（对数线性回归）的模型, 用于解决==回归类==问题

那么对于==分类==问题，我们又该使用哪种模型呢？我们知道分类问题可以分成二分类与多分类问题

此处我们先介绍二分类问题所使用的模型

我们刚学过回归类问题的模型，此时我们运用==广义线性回归==的思想，只要我们能找到一个==联系函数==，能够将连续值变成离散值，即可将回归类模型运用到分类问题上。

对数几率回归#

这里我们先给出“单位阶跃函数“(unit-step function)

此函数能够将输出范围在R上的标记转换为离散值

若预测值大于零就判为正例，小于零则判为反例，预测值为临界值零则可任意判别

在这里插入图片描述

我们可以看出这个函数的效果是很不错的但是因为其函数性质很差，不连续也不可微，不符合联系函数的定义

所以我们引进了==对数几率函数==，简称“对率函数” y=11+e−z. y = \frac { 1 } { 1 + e ^ { - z } } .y=1+e−z1. 故有 ln⁡y1−y=wTx+b. \ln \frac { y } { 1 - y } = w ^ { T } x + b .ln1−yy=wTx+b.

在这里插入图片描述

1
若将y 视为样本x 作为正例的可能性，则1 - y 是其反例可能性,两者的比值称为“几率”(odds),反映了x作为正例的相对可能性。

最小二乘法仅可解决凸函数的问题，并对于高阶函数不易用，而且对于多元回归的函数，矩阵可能无法求逆，因为其可能是不满秩的(奇异矩阵/非正定矩阵)

故我们通过极大似然法+梯度下降法进行求解

🍉Book-4章-决策树

Thu, 16 May 2024 00:00:00 GMT

递归终止条件#

决策树使用递归实现，而递归终止条件有以下三种：

当前结点所有样本属于同类，无需划分
当前属性集为空，无法划分，选取==此节点==中数量更多的标记作为类别标记
当前样本集为空，不能划分，依据==父节点==中数量更多的标记作为类别标记

名词概念#

1.纯度：同类聚集程度高、不同类越分散，则纯度越高 2.信息熵：纯度的量化指标，来源于信息论 3.剪枝：防止决策树过拟合，减去部分划分属性。分为预剪枝和后剪枝

信息熵#

==信息熵计算公式==： Ent(D)=−∑k=1∣y∣pklog⁡2pk E n t ( D ) = - \sum _ { k = 1 } ^ { | y | } p _ { k } \log _ { 2 } p _ { k }Ent(D)=−∑k=1∣y∣pklog2pk ==信息熵用于衡量信息的不确定性或信息的混乱程度==，我们可以将其用于量化纯度 信息熵越大，数据分布越均匀、随机、杂乱无章，明显这不是我们想要的。我们想要的是相同类靠近，不同类远离的效果，即需要越小的信息熵

pkp_kpk表示选到k类别的概率，而 −log⁡2pk-\log _ { 2 } p _ { k }−log2pk则表示信息量

1
我们可以理解对于某一事件，其发生的概率越小，那么其信息量越大；发生的概率越大，那么其信息量越小。所有对两者求期望即得到信息熵。

==注意==：此处计算公式里的Y的输出值种类，如二分类问题中Y=2

划分选择#

决策树中最重要的部分，用于选择最佳划分属性

1.信息增益(Information Gain)#

计算==某属性==的信息增益，用根节点的信息熵-属性各个属性值的信息熵的加权平均值 信息增益越大，意味着使用属性a进行划分获得的纯度提升越大 Gain(D,a)=Ent(D)−∑v=1V∣Dv∣∣D∣Ent(Dv) Gain ( D , a ) = E n t ( D ) - \sum _ { v = 1 } ^ { V } \frac { | D ^ { v } | } { | D | } E n t ( D ^ { v } )Gain(D,a)=Ent(D)−∑v=1V∣D∣∣Dv∣Ent(Dv)

2.增益率(Gain Ratio)#

由于信息增益对于取值数目较多的属性==有所偏好==，所以引进增益率进行选择最优划分属性，比如著名的C4.5决策树算法

==当属性a的可能取值数目越多时(即V越大)，IV(a)越小，相应的增益率就越大==

1
我们可以这样理解，IV(a)计算的其实就是信息熵，当属性值数目越多时，样本分类就越多且彼此之间就越分散越混乱，而我们希望分类效果越好，就需要减少属性值可能取值个数。

Gain Ratio(D,a)=Gain(D,a)IV(a) Gain \space R a t i o ( D , a ) = \frac { G ain( D , a ) } { I V ( a ) }Gain Ratio(D,a)=IV(a)Gain(D,a) IV(a)=−∑vV∣Dv∣Dlog⁡2∣Dv∣D I V ( a ) = - \sum _ { v } ^ { V } \frac { | D ^ { v } | } { D } \log _ { 2 } \frac { | D ^ { v } | } { D }IV(a)=−∑vVD∣Dv∣log2D∣Dv∣

思考🤔：#

增益率可以减少信息增益对于属性值较多的属性有所偏好的问题，但是同样的，==增益率对于属性值较少的属性有所偏好== 所以实际处理时，对于不同的属性的划分选择可以采取不同的方法，但是在==同一层==属性划分选择时只能使用同一种方法。

3.基尼指数(Gini Index)#

含义：==反映从数据集中随机抽取两个样本，其类别标记不一致的概率==

用于CART决策树，既可以用于==分类==问题，也可以用于==回归==问题

基尼指数越小，则数据集纯度越高 G i n i ( D ) = 1 - \sum _ { k = 1 } ^ { | y | } p _ { k } ^ { 2 }$$$$ G i n i \space I n d e x ( D , a ) = \sum _ { v = 1 } ^ { V } \frac { | D ^ { v } | } { | D | } G i n i ( D ^ { v } )

剪枝(Pruning)#

为了==防止决策树模型过拟合==而采取的手段分为预剪枝与后剪枝两种方法

==PS==：需要先选定评估方法和性能度量（第二章知识内容）下列假设使用留出法，以精度为性能度量

预剪枝(Prepruning)#

运用==贪心思想==，可能有弊端

在建立决策树的过程中进行剪枝，代入测试数据将当前精度与增加划分属性后的精度进行比较， 判断是否需要增加划分属性

后剪枝 (Postpruning)#

在决策树建立完成后进行剪枝，代入测试数据将当前精度与把该结点属性变成叶子节点后的精度进行比较 判断是否需要剪去不要的树枝 优点：欠拟合风险小，泛化性能较好

🍉Book-5章-神经网络

Thu, 16 May 2024 00:00:00 GMT

神经网络模型#

1943年一直沿用至今的M-P神经网络模型

M-P神经网络模型#

模型解释：#

将输入神经元的x乘上相应==权重w==并求和，将结果与==阈值==θ\thetaθ做差，再经过==激活函数f==得到输出值y

名词解释：#

阈值(threshold / bias): 表示神经元电位超过阈值则被激活

激活函数(activation function)：也称挤压函数或响应函数，用于将输入值映射为0/1或(0，1)

训练目标：#

通过训练模型，得出合适的w和θ\thetaθ，其中训练算法最常见的就是下面会说到的BP算法

激活函数#

回顾第三章线性模型中的对数几率回归模型和单位阶跃函数

最理想状态是用==单位阶跃函数==输入值映射为0/1，但由于其不连续、不光滑的性质，我们使用==Sigmoid函数==将输入值映射为(0，1)，Sigmoid函数即型为S的函数，其中我们最常用的就是对数几率函数： sigmoid(x)=11+e−x s i g m o i d ( x ) = \frac { 1 } { 1 + e ^ { - x } }sigmoid(x)=1+e−x1 对率函数有很好的==性质==：f′(x)=f(x)(1−f(x)) f ^ { \prime } ( x ) = f \left( x \right) ( 1 - f \left( x \right) )f′(x)=f(x)(1−f(x))

万有逼近能力#

名词概念：#

仅需一个包含足够多神经元的隐层，多层前馈神经网络就能以任意精度逼近任意复杂度的连续函数

引入原因：#

很多算法都具有万有逼近能力，不是神经网络所特有的，如决策树、支持向量机等等。而之所以在神经网络中强调其万有逼近能力，是因为其数学公理方面的理论薄弱，为了证明其有效性而进行说明。

BP算法#

误差逆传播(error BackPropagation，简称BP)算法，亦称反向传播算法

BP算法是一种迭代算法，基于==梯度下降==(gradient descent)策略，数学推导过程不多做阐述，详见西瓜书or南瓜书

缓解过拟合#

由于神经网络强大的表示能力，其经常容易过拟合，为此我们有以下两种策略

1.早停(early stopping)#

将数据集分为训练集和验证集，若验证集得到的误差升高，则停止训练。

但是很显然神经网络的误差可能是细微的波动，但却造成了训练的停止，有点像决策树中的预剪枝，基于贪心的策略。

所以采用：

若训练误差连续α轮的变化小于b，则停止训练使用验证集
若训练误差降低、验证误差升高，则停止训练

2.正则化(regularization)#

在误差目标函数中增加一项描述网络复杂度

E=λ1m∑k=1mEk+(1−λ)∑iwi2 E = \lambda \frac { 1 } { m } \sum _ { k = 1 } ^ { m } E _ { k } + ( 1 - \lambda ) \sum _ { i } w _ { i } ^ { 2 }E=λm1∑k=1mEk+(1−λ)∑iwi2

偏好比较小的连接权和阀值，使网络输出更“光滑”

🍉Book-6章-支持向量机

Thu, 16 May 2024 00:00:00 GMT

章节介绍#

统计学领域名声赫赫的SVM与核方法是时至今日仍在高频使用的经典算法。

笔记介绍#

对本章各节知识点进行汇总，主要分为引入原因，原理思想，和一些思考，对于数学推导内容介绍较少，有需要的可以先阅读西瓜书，再参考南瓜书的数学推导。

数学知识#

大部分都是规划类、最优化的问题，最好先进行相关知识的学习。

这里推荐一本书：最优化：建模、算法与理论 (刘浩洋户将李勇锋文再文)

SVM-支持向量机#

引入原因：#

在线性可分的条件下，我们在训练集做分类任务时，最基本的想法就是在样本空间中找到一个超平面进行划分, 但是对于分类任务，我们可以画出很多个超平面，这时候就需要引入损失函数，对超平面进行选择，而使得==两个异类支持向量==的距离最大化，就是我们所说的支持向量机的基本型。

数学公式及其原理：#

仍用线性模型来表示一个超平面： wTx+b=0 w ^ { T } x + b = 0wTx+b=0 而点到超平面的距离表示为：参考点到直线距离公式即可理解 r=∣wTx+b∣∣∣w∣∣ r = \frac { | w ^ { T } x + b | } { | | w | | }r=∣∣w∣∣∣wTx+b∣ 两个异类支持向量到超平面的距离（称为==间隔== margin）表示为：参考平行直线间的距离公式即可理解（此处分子为2的原因是==假设==正负类标记为+1与-1） γ=2∣∣w∣∣ \gamma = \frac { 2 } { | | w | | }γ=∣∣w∣∣2

我们的目标是使得间隔最大化，即意味着要取得∣∣w∣∣| | w | |∣∣w∣∣最小化，也就是∣∣w∣∣2| | w | | ^ { 2 }∣∣w∣∣2最小化所以我们最终可以的到SVM基本型：

求解方法：#

涉及到二次规划问题，使用==拉格朗日乘子法==解决问题，我们会得到基本型的“对偶问题”

具体方法不做详解，此处仅做大概阐述：

在SVM基本型的每条约束上增加一个拉格朗日乘子a，得到新的函数
新函数对w和b分别求偏导=0，得到w和b关于a的表达式
将表达式回代入函数，就得到了仅依赖于a的函数，就将约束问题转化成无约束问题
此时使用梯度下降、牛顿法等无约束优化算法可得出a，回代表达式得出w和b，完成原本函数的求解

核函数#

引入原因：#

由于前面的讨论都是基于训练集是==线性可分的假设== 而对于非线性可分的数据集，我们就可以采用核方法将数据集变成线性可分的

升维思想：#

找到一个函数(即核函数)将非线性可分的数据映射为线性可分的数据

常用核函数：#

下面给出常用核函数：

软间隔和正则化：#

引入原因：#

前面进行分类任务都是基于训练样本线性可分的假设，而实际应用中，训练集存在噪声或难以找到合适的核函数将数据转化为线性可分的数据如果找到了核函数也很有可能这个线性可分的结果是因为模型过拟合造成的。

所以我们引入了==软间隔==Soft Magrin这个概念，即允许部分样本划分出错。而相应的，先前我们让所有样本正确分类就叫做==硬间隔==。

正则化思想：#

其实软间隔也就是一种正则化，通过对不希望的到的结果进行惩罚，使得优化过程趋向于希望目标。

支持向量回归#

引入原因：#

我们一开始引入SVM就是为了解决分类问题，而对于回归问题是否也能通过SVM解决呢？🤔

为了解决回归问题，我们引入了==支持向量回归==，简称SVR(Support Vector Regression)

方法思想：#

在损失函数方面，与传统的回归模型用预测和标记的差别计算损失不同，

SVR容忍预测和标记之间存在偏差e，在偏差2e内都被判定为正确预测

🍉Book-1章-绪论

Wed, 15 May 2024 00:00:00 GMT

本书的使用：#

第1章-绪论

计算学习理论#

概率近似正确 模型：PAC (Probably Approximate Correct)

公式：P(∣f(x)−y∣≤ϵ)≥1−δ P ( | f ( x ) - y | \leq \epsilon ) \geq 1 - \deltaP(∣f(x)−y∣≤ϵ)≥1−δ

其中 f 表示模型，y表示真相，x为样本

公式分析：

其中∣f(x)−y∣≤ϵ | f ( x ) - y | \leq \epsilon∣f(x)−y∣≤ϵ 用于计算模型的误差，判断模型的优劣

由于模型基于不同的算法和数据是不唯一的

故用P(......)≥1−δ P ( ...... ) \geq 1 - \deltaP(......)≥1−δ 表示取得该模型的概率

故当δ=0，ϵ=0 \delta=0，\epsilon=0δ=0，ϵ=0时，即表示每次都取到最优解的模型

这时就出现了P=NP的问题

只要我们相信P≠NP，那么就不可能每次都取到最优模型

P=NP问题是计算机科学中的一个著名未解之谜，它询问的是两个问题类别——P类问题和NP类问题——是否相等。P类问题是指那些可以被快速解决的计算问题，即存在一个多项式时间算法来解决这些问题。NP类问题则是指那些虽然可能很难快速解决，但如果给出一个解决方案，我们可以快速验证这个解决方案是否正确的问题。
简单来说，P=NP问题问的是：所有可以快速验证答案的问题，是否都可以快速解决？

术语名词#

1.示例 = 特征向量，样本

名词解释:即对某个事件或者对象的全局描述
构成元素:多组(特征:特征值)
样本要根据上下文来判断含义

2.特征 = 属性

名词解释：即对某个事件或对象的一个具体特征的描述

3.样本空间 = 属性空间 = 输入空间

名词解释：即特征张成的空间，空间中每个点对应一个特征向量即样本

4.数据集，训练集，测试集

数据集=训练集+测试集（一般二八分，训练集更多）

数据集一般这样表示：

D={x1,x2,…,xm}D =\left\{x_{ 1 },x_{2},\ldots,x_{ m }\right\}D={x1,x2,…,xm}

由m个样本X构成，每个样本有相同的d个特征，即样本的维数为d

5.样例，标记，标记空间

样例=样本+标记

标记：即想预测的结果的实际信息，比如想预测瓜的好坏，实际样本中的信息为”好瓜”/“坏瓜”，

一般这样表示： (xi,yi) ( x _ { i } , y _ { i } )(xi,yi)

标记空间 or 输出空间：所有标记的集合

6.假设空间，版本空间

1
假设：学得模型关于数据的潜在规律
2

3
真实or真相：潜在规律本身
4

5

6
假设空间：所有假设构成的集合
7

8
版本空间：与训练集一致的假设构成的集合，由一个或多个假设空间的子集构成

…

基本假设#

我们知道训练出的模型是为了对未知数据进行结果预测

但是为什么模型可以对未知数据进行预测呢？

这里我们引出了机器学习的基本假设。

1.未知分布D#

通常假设样本空间中全体样本服从一个未知“分布” D
此处的“分布”指的是概率论中的概率分布

我们假设数据（包括源数据集和未知数据）背后满足某种规律，

即数据的采样来自一个未知的、潜在的分布D

2.独立同分布（i.i.d）#

我们获得的每个样本都是独立地从这个分布上采样获得的，即“独立同分布”（简称i.i.d）

或者说所有样本都是独立同分布的

一般而言，训练样本越多，我们得到的关于D的信息也越多

3.一些思考#

在现实生活中，大多数样本之间不是独立同分布的，而是相互影响的。

比如说：在淘宝上买衣服的人和买裤子的人，它们之间可能来自不同的分布，可能买衣服的人推荐买裤子的人来淘宝购物。

所以现在在机器学习的前沿领域，

如何突破独立同分布的限制 是一个重大课题

归纳偏好#

归纳偏好对应了学习算法本身所做出的关于“什么样的模型更好”的假设

对假设空间筛选后所得到的版本空间中可能有多个假设这些假设都能够匹配训练集中的训练样本

而如何对版本空间中的假设进行选择呢？🤔

这里引入一个原则or方法论：

奥卡姆剃刀：

若非必要勿增实体
选取多个假设中最简单的。

但是其实感觉没啥用，因为”简单“的定义难以量化。

一个“随机乱猜”的算法有可能优于精心选择的算法

“没有免费的午餐”（NFL）定理：

1
任意算法的“训练集外误差”相等，即不同算法的误差期望相同，无绝对意义上的更优算法。

所以 不能摆脱具体问题 谈论算法的优劣

实际上：还是看测试集再模型上的效果，以及结合特定领域的需求对模型进行选择

机器学习分类#

1.监督学习-有导师学习#

样本有标记

1.1 分类问题-预测 离散值

二分类-正类/负类(反类)

一般取值0/1，文本可通过特征工程转换为数值型变量

一般假设正类和负类是可交换的
多分类 涉及多类别的预测输出

可以转换成二分类问题

1.2 回归问题-预测 连续值

1
预测结果 ∈ R

2.非监督学习-无导师学习#

样本无标记

2.1 聚类算法

离散型变量的分类、分组别
连续型变量的统计个数，进行密度估计

了解数据内在规律

2.2 降维算法

如PCA主成分分析等

…

机器学习的发展#

符号主义：源于数学逻辑，产生明确的概念表示

符号主义认为人工智能源于数理逻辑后来又发展了启发式算法>专家系统>知识工程理论与技术

主要方向：决策树和基于逻辑的学习
```
1
  决策树->模拟人类对概念的判定树形过程
2

3
  基于逻辑的学习-->典型代表：归纳逻辑程序设计(ILP)
```
连接主义：基于神经网络

算法复杂度高，假设空间大，且参数设置缺乏理论指导

经典代表：BP反向传播算法
统计学习：支持向量机(SVM)，核方法

与连接主义关系密切
深度学习：早期连接主义的衍生，基于神经网络，现阶段很流行

定义类和方法

Tue, 14 May 2024 00:00:00 GMT

对象是实例化的类，所以对象也叫做实例。

一个实例(对象)由属性 (变量or数据)和方法 (行为)构成

所以属性和方法叫做对象的成员

对象的属性叫做成员变量or实例变量(这俩也有点区别)

对象的方法叫做成员方法

在面向对象编程中，成员变量和实例变量通常指的是相同的概念，但它们的使用和含义略有不同，具体取决于上下文：

成员变量：
- 成员变量是类的一部分，它们定义了类的状态或属性。
- 每个成员变量都是类的蓝图，用于创建对象时存储数据。
- 成员变量可以是静态的或非静态的（实例变量）。
实例变量（非静态变量）：
- 实例变量是成员变量的一种，它们属于类的特定实例（对象）。
- 每个实例变量的副本都存储在创建的对象中，这意味着每个对象都有自己的实例变量副本。
- 实例变量的值对于每个对象都是独立的，一个对象的实例变量改变不会影响另一个对象的相应变量。
静态变量（类变量）：
- 静态变量也是成员变量的一种，但它们不属于任何特定的实例。
- 静态变量只有单一的副本，所有类的实例共享这个副本。
- 静态变量通常用于存储类级别的数据，如配置信息或计数器。

以下是一些关键点的对比：

作用域：实例变量属于对象，每个对象都有其独立的副本；静态变量属于类，所有实例共享同一个副本。
生命周期：实例变量随对象的创建而存在，随对象的销毁而消失；静态变量随类的加载而存在，随程序结束或类被卸载而消失。
访问：实例变量可以通过对象的引用访问；静态变量可以通过类名直接访问，也可以通过对象引用访问。

下面是一个简单的Java类示例，展示了实例变量和静态变量的使用：

1
public class Car {
2
    // 实例变量，每个Car对象都有自己的颜色和速度
3
    String color;
4
    int speed;
5

6
    // 静态变量，所有Car对象共享同一个制造数量
7
    static int manufacturingCount = 0;
8

9
    public Car(String color) {
10
        this.color = color;
11
        // 每创建一个Car对象，制造数量增加
12
        manufacturingCount++;
13
    }
14

15
    public void drive() {
16
        // 实例方法，影响特定对象的速度
17
        speed += 10;
18
    }
19

20
    public static int getManufacturingCount() {
21
        // 静态方法，返回所有Car对象共享的制造数量
22
        return manufacturingCount;
23
    }
24
}

展开收起

在这个例子中，color 和 speed 是实例变量，因为它们属于每个 Car 对象。而 manufacturingCount 是一个静态变量，因为它属于 Car 类本身，并且所有 Car 实例共享这个变量。drive 方法是一个实例方法，因为它操作特定 Car 对象的速度。getManufacturingCount 是一个静态方法，因为它返回的是类级别的信息。

在Java中，类（Class）是用来创建对象的模板或蓝图。类本身不直接持有数据，但类定义中可以包含成员变量（也称为字段或属性），这些成员变量是用来存储数据的。当你根据类创建一个对象（实例）时，每个对象都会有自己的成员变量副本，这些副本中存储的就是数据。

例如，假设有一个名为 Person 的类：

1
public class Person {
2
    String name;
3
    int age;
4

5
    public Person(String name, int age) {
6
        this.name = name;
7
        this.age = age;
8
    }
9

10
    // 其他方法...
11
}

在这个 Person 类中，name 和 age 就是成员变量，它们可以在类的实例中存储数据。当你创建 Person 类的对象时：

1
Person person1 = new Person("Alice", 30);
2
Person person2 = new Person("Bob", 25);

person1 和 person2 都是 Person 类的实例，它们各自拥有自己的 name 和 age 数据。person1 的 name 是 “Alice”，age 是 30；而 person2 的 name 是 “Bob”，age 是 25。

类本身只是一个定义，它不包含数据，但是它定义了如何创建可以包含数据的对象。

在面向对象编程（OOP）中，成员是类的一部分，它代表了类的特性（属性）或行为（方法）。成员是构成类的基本元素，它们定义了类的功能和数据结构。以下是成员的两种主要类型：

成员变量（属性）：
- 成员变量是类的一部分，用于存储数据。它们是类的属性，通常用于描述对象的状态。
- 成员变量可以是私有的（private），这意味着它们只能被类内部的方法访问，或者可以是公有的（public），这意味着它们可以被任何其他类访问。
- 成员变量可以有默认的访问修饰符（没有显式指定），这通常是包级私有的（即同一个包内的其他类可以访问）。
成员方法（行为）：
- 成员方法是类的一部分，定义了对象的行为。它们是类的操作，用于描述对象可以执行的动作。
- 成员方法可以有不同的访问修饰符，如public、private或protected，这决定了它们可以被谁调用。
- 方法还可以是静态的（static），这意味着它们属于类而不是类的实例，并且可以在不创建类实例的情况下被调用。

除了成员变量和成员方法，类的成员还可以包括：

构造方法：特殊的方法，用于创建类的对象。它们的名字必须与类名相同，并且没有返回类型。
静态初始化块：用于初始化静态变量的代码块，它在类加载时执行一次。
实例初始化块：用于初始化非静态变量的代码块，它在每次创建类的新实例时执行。
内部类：定义在另一个类内部的类，它可以访问外部类的成员，包括私有成员。

成员变量和方法的可见性和行为可以通过使用不同的访问修饰符和非访问修饰符来控制。例如：

1
public class ExampleClass {
2
    // 成员变量
3
    private int privateVar;
4
    protected int protectedVar;
5
    int packageVar; // 默认访问修饰符，也称为包级私有
6
    public int publicVar;
7

8
    // 构造方法
9
    public ExampleClass() {
10
        // 构造逻辑
11
    }
12

13
    // 成员方法
14
    public void publicMethod() {
15
        // 方法逻辑
16
    }
17

18
    private void privateMethod() {
19
        // 私有方法逻辑
20
    }
21

22
    // 静态方法
23
    public static void staticMethod() {
24
        // 静态方法逻辑
25
    }
26

27
    // 实例初始化块
28
    {
29
        // 实例初始化逻辑
30
    }
31

32
    // 静态初始化块
33
    static {
34
        // 静态初始化逻辑
35
    }
36
}

展开收起

在这个例子中，ExampleClass 包含了不同类型的成员，包括私有和公有的成员变量，一个构造方法，公有和私有的成员方法，以及静态方法。静态初始化块和实例初始化块分别用于初始化静态成员和非静态成员。

在Java语言中，this 是一个特殊的关键字，它指向当前对象的引用。每个对象都有一个隐式的 this 引用，指向它自己。以下是 this 关键字的一些常见用法：

区分成员变量和局部变量：当局部变量名与成员变量名相同时，可以使用 this 关键字来区分它们。

1
public class MyClass {
2
    private int number;
3
    public MyClass(int number) {
4
        this.number = number; // 使用 this 来引用成员变量
5
    }
6
}

在构造函数中调用另一个构造函数：可以使用 this() 来调用同一个类中的另一个构造函数。

1
public class MyClass {
2
    private int number;
3
    public MyClass() {
4
        this(0); // 默认构造函数调用带参数的构造函数
5
    }
6
    public MyClass(int number) {
7
        this.number = number;
8
    }
9
}

在方法中返回当前对象的引用：有时，方法需要返回调用该方法的对象的引用，这时可以使用 this。

1
public class MyClass {
2
    public MyClass getNext() {
3
        // 一些逻辑...
4
        return this; // 返回当前对象的引用
5
    }
6
}

在参数中传递当前对象：当需要将当前对象作为参数传递给另一个方法时，可以使用 this。

1
public class MyClass {
2
    public void doSomething(MyClass other) {
3
        other.copy(this); // 将当前对象作为参数传递
4
    }
5
    public void copy(MyClass other) {
6
        // 复制逻辑...
7
    }
8
}

在匿名类和内部类中引用外部类的实例：在匿名类或内部类中，可以使用 this 关键字来引用外部类的实例。

1
public class OuterClass {
2
    public void doSomething() {
3
        new Thread(new Runnable() {
4
            public void run() {
5
                OuterClass.this.doWork(); // 调用外部类的 doWork 方法
6
            }
7
        }).start();
8
    }
9
    public void doWork() {
10
        // 工作逻辑...
11
    }
12
}

在重载方法中使用：当类中有多个同名方法但参数列表不同时，可以使用 this 调用其他重载的方法。

1
public class MyClass {
2
    public void print(int number) {
3
        System.out.println("Number: " + number);
4
    }
5
    public void print(String text) {
6
        System.out.println("Text: " + text);
7
    }
8
    public void printAll(int number, String text) {
9
        this.print(number); // 调用第一个 print 方法
10
        this.print(text); // 调用第二个 print 方法
11
    }
12
}

this 关键字是Java中一个非常有用的工具，它允许程序员在各种情况下引用当前对象。

Hexo搭建实遇问题

Mon, 13 May 2024 00:00:00 GMT

1.spawn_failed问题#

原因分析：#

其实出现这个问题，很大可能是因为https和http的proxy的对应的分别是https和http开proxy server，

而https的proxy server可能无法正常工作。

解决办法：#

修改_config.yml文件的deploy部分，将https 修改为http url 或者设置为git url, 配置为https oauth2 加token

设置为git url(推荐) 亲测有效

1
    deploy:
2
        type: git
3
        repo: git@github.com:your_github_id/your_github_id.github.io.git
4
        branch: gh-pages

2.头像无法显示问题#

原因分析：#

不明原因，猜测是路径问题

解决方法1：#

将想要显示的头像图片存入本地文件夹
在根目录下进入git bash使用hexo g和hexo d上传代码到github仓库
在github仓库找到该图片，鼠标右键复制图片链接
修改主题配置文件，如我修改的为config.butterfly.yml文件

1
#Avatar (頭像)
2
avatar:
3
  img: 输入你复制的图片链接
4
  # effect为true 则鼠标放于图片上，会使图片一直旋转
5
  effect: false

解决方法2：#

更改默认头像路径

默认路径："C:\Users\陈荣伟\Desktop\Blog\Hexo-blog\blog\themes\butterfly\source\img\friend_404.gif"

把需要的头像名称改为friend_404.gif，把friend_404.gif 重命名成别的即可

_config.butterfly.yml内的配置文件

1
# Replace Broken Images (替换无法显示的图片)
2
error_img:
3
  flink: /img/friend_404.gif
4
  post_page: /img/404.jpg

3.本地预览正常，但部署到GitHub 网站背景图片不加载#

解决方法：#

分清背景图片是放在本地还是别处？
记得用图片的网络链接，确保图片地址没有错误。
然后清除浏览器缓存再试试

hexo clean命令#

1
hexo clean

清除缓存文件 db.json 和已生成的静态文件 public。

网站显示异常时可以执行这条命令试试。

接着依次运行代码：

1
hexo g

1
hexo d

终极方法#

删除.deploy_git和public文件

4.插入图片的显示问题#

参考文章：

在hexo博客中插入图片的方法_hexo插入图片-CSDN博客

插入图片的方法在完成了博客搭建、发布文章后，如果我们想在文章中插入图片，该怎么做呢？

如果图片保存在本地

方法一：全局资源文件夹#

即，将所有文章的资源统一用一个全局资源文件夹管理。

此方法的优点是比较简便，并且当多篇文章需要引用同一资源时，也比较方便。

缺点是当文章很多时，各个文章的图片都在同一文件夹，不便管理。

具体方法：在hexo文件夹下的source目录下，新建一个文件夹叫images(名字随意)，将要插入的图片放在该文件夹中。 md文档内，使用的格式，圆括号内的链接地址写(/images/name.jpeg)。这里的 / 指的是根目录，对于hexo，资源文件的根目录就是source(可以在config文件里修改资源的根目录)

例如，在md文档中写：![图片](/images/20.jpeg "甘雨") 同时将“20.jpeg”这个图片文件放在hexo文件夹/source/images下，则图片可以上传到博客。

方法二：文章资源文件夹#

即，对于每篇文章，使用一个文件夹管理资源。

此方法的优点是，当文章很多时，便于结构化管理。

缺点是，比方法一麻烦一点。

具体方法：

2.1 修改hexo文件夹中的_config.yml文件，如下：

1
post_asset_folder: true
2
marked:
3
  prependRoot: true
4
  postAsset: true

2.2 在终端cd到hexo文件夹，hexo new 文章名 命令创建一篇新文章，此时会在hexo文件夹的source目录下，自动创建一个文件夹和文章名.md文件。

注：如果文章名中有空格，务必将整个文章名用双引号引起来。如果文章名中没有空格，可以加双引号，也可以不加。

例如，执行hexo new “如何发布文章到hexo博客上”，如下：

会在source/_post文件夹下生成一个”如何发布文章到hexo博客上.md”文件。如下：

可以看到，同时还生成了一个同名的资源文件夹。

2.3 我们可以将所有与该文章有关的资源（包括图片）放在这个关联文件夹中 2.4 通过相对路径来引用图片资源。

例如，将“1.jpeg”这个图片资源放在该文件夹中，并在.md文件中像这样引用图片：，这个方法在资源较多时方便管理。

另附Typora编辑器中不显示图片的解决方案：安装下面的插件，可以使Typora等Markdown编辑器预览以及Hexo发布预览时，均能正常显示图片。 npm install hexo-asset-img --save 这样，如果你使用Typora编辑markdown文档，在typora内也可以显示图片了。

5.4000端口占用问题#

查看端口:#

1
netstat -ano

1
    每一列分别对应：协议、本地地址、外部地址、状态、PID
2

3
  参数详解：
4
    -a            显示所有连接和侦听端口。
5
    -n            以数字形式显示地址和端口号。
6
    -o            显示拥有的与每个连接关联的进程 ID。

注：其余参数可使用help命令查看：

netstat -help

查询出的端口数量很多，我们可使用findstr命令进行过滤：

1
netstat -ano | findstr "被占用的端口"

释放被占用的端口：#

过滤出需要释放的端口后，在cmd窗口输入task kill命令 可释放被占用的端口：

1
taskkill -f -t /pid "占用端口的程序的pid"

6.网页渲染Latex问题#

修改主题配置文件_config.butterfly.yml：

1
mathjax:
2
  enable: true
3
  # true 表示每一頁都加載mathjax.js
4
  # false 需要時加載，須在使用的Markdown Front-matter 加上 mathjax: true
5
  per_page: false

以下操作在你 hexo 博客的目录下 (不是 Butterfly 的目录):

安装插件

1
npm uninstall hexo-renderer-marked --save
2
npm install hexo-renderer-kramed --save

配置 hexo 根目录的配置文件_config.yml

1
kramed:
2
  gfm: true
3
  pedantic: false
4
  sanitize: false
5
  tables: true
6
  breaks: true
7
  smartLists: true
8
  smartypants: true

7.引入CSS文件#

打开config.butterfly.yml文件

CTRL+F 搜索下面的代码，增加<link>标签即可

1
inject:
2
  head:
3
    # - <link rel="stylesheet" href="/xxx.css">
4
    - <link rel="stylesheet" href="/css/categories_dark_fit.css">
5
    - <link rel="stylesheet" href="/css/butterfly_article_double_row.css">
6
  bottom:
7
    # - <script src="xxxx"></script>

Celyn's Blog

【Claude_Code_CLI安装】代理配置-本地模型-插件生态

1 前言#

2 安装#

3 cc switch 多模型配置切换#

4 配置 DeepSeek 兼容端点#

4.1 获取 API Key#

4.2 配置自定义端点#

5 接入本地模型（llama.cpp）#

5.1 内网穿透（ngrok）#

5.2 在 Claude Code 中连接 llama.cpp#

5.3 切换模型#

5.4 缺点#

5.5 CC switch实际修改配置#

6 Skill、Plugin、Agent 扩展#

6.1 添加市场#

6.2 浏览与安装#

7 小结#

【Git】项目协作开发教程

1 前言#

2 Git 基础全局配置#

2.1 验证配置是否成功#

3 Git 代理配置（解决 GitHub 下载慢）#

3.1 设置 7897 端口代理#

3.2 验证代理是否生效#

3.3 取消代理（备用）#

4 Fork 仓库与本地初始化#

4.1 Fork 上游仓库#

4.2 本地初始化仓库#

4.2.1 方式 1：下载 ZIP 压缩包后初始化#

4.2.2 方式 2：直接 Git Clone（推荐）#

5 分支开发与代码提交#

5.1 创建开发分支#

5.2 修改代码与提交#

6 同步上游更新与推送代码#

6.1 场景 1：上游仓库无新提交#

6.2 场景 2：上游仓库有新提交#

6.3 提交 PR 到上游仓库#

7 PR 被合并后：同步代码 + 清理分支#

7.1 常见问题提示#

8 总结#

【n8n】基于WSL2-Docker完整部署教程

1 引言：为什么使用 n8n#

2 WSL 下载配置#

2.1 WSL 内核更新#

2.2 手动安装 Ubuntu22.04（清华镜像离线导入）#

2.3 常见报错处理：#

2.3.1 开启系统必要功能（管理员 PowerShell 逐条执行）#

2.3.2 图形化检查 Windows 功能#

2.3.3 开启 CPU 虚拟化#

2.3.4 重新执行导入命令#

3 Docker下载与配置#

3.1 Docker Desktop下载#

3.2 Docker Resources#

3.2.1 Advanced 设置#

3.3 WSL integration 配置#

3.4 Docker Engine 镜像加速配置#

4 n8n 部署与使用#

4.1 Docker 部署启动 n8n#

4.2 n8n 的webui界面操作#

5 参考文档：#

神经网络优化核心：鞍点而非局部极小值

1 前言#

2 梯度下降收敛停滞的关键原因#

3 Hessian 矩阵与二次型#

4 收敛点的真实本质#

5 总结#

【IP地址防护】-预防WebRTC泄露

什么是 WebRTC 泄露（WebRTC Leak），如何预防#

使用 IPPure 检查 WebRTC 泄露情况#

安装前：#

安装后 ：#

Reference：#

【爬虫脚本自动化录制】playwright-codegen使用教程

前言#

什么是 playwright codegen？#

环境准备#

安装 Playwright#

安装浏览器驱动#

codegen 基础使用#

3 `cc switch` 多模型配置切换#

安装后：#