UI-TARS 论文

要让Cursor（VSCode）在Windows任务栏显示工程名称而不是文件名，需要修改VSCode的窗口标题配置。具体步骤如下：
方法一：通过设置界面修改
1. 打开Cursor/VSCode，按 `Ctrl+,` 打开设置
2. 在搜索框中输入 window.title
3. 将默认值修改为：


```bash
${dirty}${rootName}${separator}${activeEditorMedium}${separator}${appName}
```


也就是填写到这里ctrl+S就行了：
![image.png](/static/img/724d12d2ea1f7b6f77a141dc81c5f9a9.image.webp)



Cursor（VSCode）在Windows任务栏显示工程名称而不是文件名

EvoLM LLM炼丹师最优配方

qwen3vl的tools设计验证

stepfun-ai/GELab-Zero-4B-preview

win：
```js
C:\Users\Administrator\.wslconfig
```
win写这个文件为：
```js
[wsl2]
networkingMode=mirrored
dnsTunneling=true
firewall=false
autoProxy=true
```
win重启，然后ps关闭防火墙：

```js
# 允许 ICMPv4 入站流量（针对 ping）
New-NetFirewallRule -DisplayName "WSL Ping Allow" -Direction Inbound -InterfaceAlias "vEthernet (WSL)" -Action Allow -Protocol ICMPv4
```


wsl:

```js
cc@DESKTOP-564RG57:~$ cat /etc/resolv.conf
# This file was automatically generated by WSL. To stop automatic generation of this file, add the following entry to /etc/wsl.conf:
# [network]
# generateResolvConf = false
nameserver 172.21.160.1

```
wsl ping 这个nameserver。




wsl和win无法互相ping

Open-AutoGLM

https://github.com/wgzhao/dbeaver-agent/issues/18

https://dbeaver.com/download/ultimate/


![image.png](/static/img/78d336235fd6e3ef139748fcc7ad7ad5.image.webp)


```bash
java -cp "plugins\*;.\dbeaver-agent-25.3-SNAPSHOT-jar-with-dependencies.jar" com.dbeaver.agent.License
```



1、降级版本到25.0

2、下载jdk25

2.1、复制dbeaver-agent-25.0-SNAPSHOT-jar-with-dependencies.jar，也可自行下源码打包

3、

4、

java -cp "D:\dbeaver-ue-25.0.0-win32.win32.x86_64\dbeaver\plugins\*;D:\dbeaver-ue-25.0.0-win32.win32.x86_64\dbeaver\dbeaver-agent-25.0-SNAPSHOT-jar-with-dependencies.jar" com.dbeaver.agent.License


5、dbeaver.ini 按照在结尾新增

+ -javaagent:dbeaver-agent-25.0-SNAPSHOT-jar-with-dependencies.jar
+ -Xbootclasspath/a:dbeaver-agent-25.0-SNAPSHOT-jar-with-dependencies.jar

6、运行dbeaver.exe




DBeaver Ultimate Edition 

# 深入理解 GRPO 强化学习:从 PPO 到 Group Relative Policy Optimization

当 DeepSeek-R1 横空出世,以开源姿态挑战 OpenAI 的 o1 模型时,整个 AI 社区都在关注一个问题:他们是如何做到的?答案的关键之一就是 **GRPO (Group Relative Policy Optimization)** —— 一种更高效的强化学习算法。

本文将带你从零开始理解 GRPO,看看它如何在保持性能的同时,将训练成本降低了近 50%。



## 一、从一个类比开始:小学生考试的故事

在深入技术细节之前,让我们用一个简单的类比来理解强化学习的核心思想。

### 1.1 最简单的情况:只看绝对分数

想象你是一个小学生,每次考试后:
- 考了 90 分 → 很开心,下次继续这样做
- 考了 60 分 → 不太好,下次要改进

这就像最基础的强化学习:**根据奖励(分数)调整行为**。

但这有个问题:假如这次考试特别难,全班平均分只有 50 分,你考了 60 分其实已经很不错了。但如果你只看绝对分数,可能会错误地认为自己表现不好。

### 1.2 引入"基准线":父母的期望

聪明的父母会这样做:
- 如果你通常考 80 分,这次考了 85 分 → 超出预期,奖励!
- 如果你通常考 80 分,这次考了 75 分 → 低于预期,需要改进

这个"通常考多少分"就是**基准线(Baseline)**。我们不再看绝对分数,而是看**相对于基准线的表现**。

在强化学习中,这个差值叫做 **Advantage(优势)**:

```
Advantage = 实际得分 - 基准线
```

- Advantage > 0:表现好于预期,增强这个行为
- Advantage < 0:表现差于预期,减弱这个行为

**这就是 PPO 和 GRPO 的核心思想!**

## 二、理解 PPO:传统的强化学习方法

在介绍 GRPO 之前,我们需要理解它的前身 —— PPO (Proximal Policy Optimization),这是 ChatGPT 使用的强化学习算法。

### 2.1 PPO 的完整流程

假设我们要训练一个数学推理模型,PPO 的流程是这样的:

**步骤 1:生成回答**
给模型一个问题:"计算 25 × 4 = ?"
模型生成回答:"25 × 4 = 100"

**步骤 2:奖励模型评分**
用一个专门训练的**奖励模型(Reward Model)**给这个回答打分:
- 答案正确 → +10 分
- 格式规范 → +2 分
- 总分:**12 分**

**步骤 3:价值模型估计基准**
这是 PPO 的关键组件 —— **价值模型(Value Model / Critic)**:

价值模型会预测:"对于这个问题,平均来说应该能得多少分?"
假设价值模型估计:基准线 = 8 分

**步骤 4:计算 Advantage**
```
Advantage = 实际奖励 - 价值模型估计
         = 12 - 8 
         = +4
```

这个 +4 表示这次表现比预期好 4 分。

**步骤 5:更新模型**
基于这个 Advantage,我们会:
- 增加生成这个回答的概率(因为 Advantage > 0)
- 同时更新价值模型,让它的估计更准确

### 2.2 PPO 需要哪些"模型"?

PPO 训练需要 **4 个大型模型**同时工作:

1. **策略模型(Policy Model)** - 要训练的 LLM 本身
2. **奖励模型(Reward Model)** - 给回答打分
3. **价值模型(Value Model / Critic)** - 估计基准线
4. **参考模型(Reference Model)** - 原始模型的冻结副本,防止模型改变太大

这 4 个模型都是大型神经网络,通常都有几十亿参数,对内存和计算资源的要求非常高!

### 2.3 PPO 的目标函数

PPO 的数学目标是:

$$J_{PPO}(\theta) = \mathbb{E}\left[\min\left(\frac{\pi_\theta(a|s)}{\pi_{\theta_{old}}(a|s)} A^t, \text{clip}\left(\frac{\pi_\theta(a|s)}{\pi_{\theta_{old}}(a|s)}, 1-\epsilon, 1+\epsilon\right) A^t\right)\right]$$

看起来复杂,但本质是:
- $A^t$ 是 Advantage
- $\frac{\pi_\theta(a|s)}{\pi_{\theta_{old}}(a|s)}$ 是概率比(新模型生成这个回答的概率 / 旧模型生成的概率)
- $\text{clip}(...)$ 限制更新幅度,防止模型变化太大
- $\min(...)$ 选择更保守的更新方向

## 三、GRPO 的核心创新:不需要价值模型!

GRPO 的关键创新在于:**用一组回答的平均奖励替代价值模型**。

### 3.1 GRPO 的基本思路

回到考试的类比:

**PPO 的做法:**
- 父母(价值模型)根据你平时的表现预测:"这次考试你大概能考 80 分"
- 你考了 85 分 → Advantage = +5

**GRPO 的做法:**
- 不需要父母预测,让你做同一份试卷 **8 次**
- 你 8 次分别考了:82, 78, 90, 75, 88, 80, 85, 92
- 平均分 = 83.75
- 某一次考了 90 分 → Advantage = 90 - 83.75 = +6.25
- 某一次考了 75 分 → Advantage = 75 - 83.75 = -8.75

**核心思想:用同一组问题的多次尝试的平均值作为基准线,而不是训练一个单独的模型来预测基准线。**

### 3.2 GRPO 的详细流程

让我们看一个具体例子:

**输入问题:**
```
"What is 13 × 17?"
```

**步骤 1:生成一组回答(Group)**

对同一个问题,让模型生成 G=4 个不同的回答:

```python
回答 1: "13 × 17 = 221"         # 正确
回答 2: "13 × 17 = 230"         # 错误
回答 3: "13 × 17 = 221"         # 正确
回答 4: "Let me think... 221"  # 正确但格式不好
```

**步骤 2:奖励模型评分**

每个回答通过奖励模型获得分数:

```python
回答 1: r₁ = 10.0  (完全正确)
回答 2: r₂ = 0.0   (答案错误)
回答 3: r₃ = 10.0  (完全正确)
回答 4: r₄ = 7.0   (答案对但格式差)
```

**步骤 3:计算这一组的平均奖励和标准差**

```python
平均奖励 = (10.0 + 0.0 + 10.0 + 7.0) / 4 = 6.75
标准差 = 4.27
```

**步骤 4:计算每个回答的归一化 Advantage**

GRPO 使用标准化的 Advantage(类似 Z-score):

$$\hat{A}_i = \frac{r_i - \text{mean}(r)}{\text{std}(r)}$$

```python
Advantage₁ = (10.0 - 6.75) / 4.27 = +0.76  (好于平均)
Advantage₂ = (0.0 - 6.75) / 4.27  = -1.58  (远差于平均)
Advantage₃ = (10.0 - 6.75) / 4.27 = +0.76  (好于平均)
Advantage₄ = (7.0 - 6.75) / 4.27  = +0.06  (略好于平均)
```

**步骤 5:更新模型**

- 回答 1 和 3:Advantage 为正,增加生成类似回答的概率
- 回答 2:Advantage 为负且很大,大幅降低生成类似回答的概率
- 回答 4:Advantage 略为正,稍微增加概率

### 3.3 为什么要标准化?

标准化(除以标准差)有重要作用:

**情况 A:回答质量差异大**
```
回答奖励:[10, 9, 2, 1]
平均:5.5,标准差:4.2
Advantage₁ = (10-5.5)/4.2 = 1.07
```

**情况 B:回答质量都差不多**
```
回答奖励:[6, 6, 5, 5]
平均:5.5,标准差:0.58
Advantage₁ = (6-5.5)/0.58 = 0.86
```

虽然都是 +0.5 的差值,但情况 A 中的差异更显著,所以得到更大的 Advantage。这让训练更稳定。

## 四、GRPO 的数学公式

理解了核心思想后,让我们看看完整的数学形式。

### 4.1 Advantage 计算

对于问题 $q$,生成 $G$ 个回答 $\{o_1, o_2, ..., o_G\}$,每个获得奖励 $r_i$:

$$\hat{A}_i = \frac{r_i - \frac{1}{G}\sum_{j=1}^G r_j}{\sqrt{\frac{1}{G}\sum_{j=1}^G (r_j - \bar{r})^2}}$$

简化写法:

$$\hat{A}_i = \frac{r_i - \text{mean}(r)}{\text{std}(r)}$$

### 4.2 GRPO 目标函数

完整的 GRPO 目标是:

$$J_{GRPO}(\theta) = \mathbb{E}\left[\frac{1}{G}\sum_{i=1}^G \frac{1}{|o_i|}\sum_{t=1}^{|o_i|} \min\left(\rho_t \hat{A}_i, \text{clip}(\rho_t, 1-\epsilon, 1+\epsilon) \hat{A}_i\right) - \beta D_{KL}\right]$$

其中:
- $\rho_t = \frac{\pi_\theta(o_{i,t}|q, o_{i,<t})}{\pi_{\theta_{old}}(o_{i,t}|q, o_{i,<t})}$ 是概率比
- $\hat{A}_i$ 是归一化的 Advantage
- $\text{clip}(\rho_t, 1-\epsilon, 1+\epsilon)$ 限制概率比在 $[1-\epsilon, 1+\epsilon]$ 范围内(通常 $\epsilon=0.2$)
- $\beta D_{KL}$ 是 KL 散度惩罚项(可选,现代实现通常设为 0)

### 4.3 公式拆解

让我们逐部分理解:

**1. 概率比 $\rho_t$**

$$\rho_t = \frac{\pi_\theta(o_{i,t}|q, o_{i,<t})}{\pi_{\theta_{old}}(o_{i,t}|q, o_{i,<t})}$$

这是"新模型生成这个 token 的概率"除以"旧模型生成这个 token 的概率":

- $\rho_t > 1$:新模型更倾向于生成这个 token
- $\rho_t < 1$:新模型更不倾向于生成这个 token
- $\rho_t = 1$:概率没变

**2. 为什么需要 clip?**

想象一个极端情况:
- 旧模型生成某个 token 的概率:0.001
- 新模型生成的概率:0.5
- 概率比 = 500!

如果不限制,这会导致梯度爆炸。clip 函数将其限制在合理范围:

$$\text{clip}(\rho_t, 1-\epsilon, 1+\epsilon) = \text{clip}(\rho_t, 0.8, 1.2)$$

**3. min 操作**

$$\min(\rho_t \hat{A}_i, \text{clip}(\rho_t, 1-\epsilon, 1+\epsilon) \hat{A}_i)$$

这个 min 的作用是:**选择更保守的更新**。

- 如果 Advantage > 0(好的行为):我们想增大概率,但 clip 防止增大太多
- 如果 Advantage < 0(坏的行为):我们想减小概率,但 clip 防止减小太多

**4. 对所有 token 平均**

$$\frac{1}{|o_i|}\sum_{t=1}^{|o_i|}$$

虽然 Advantage 是对整个回答计算的,但更新是对每个 token 进行的。我们把整个序列的 Advantage 分配给每个 token。

## 五、PPO vs GRPO:直观对比

让我们用一张对比表总结区别:

| 特性 | PPO | GRPO |
|------|-----|------|
| **所需模型数量** | 4 个(策略、奖励、价值、参考) | 2-3 个(策略、奖励,可选参考) |
| **基准线来源** | 价值模型预测 | 同组回答平均值 |
| **内存占用** | 高(需要额外的价值模型) | 低(省去价值模型) |
| **计算开销** | 需要训练价值模型 | 只需多次采样 |
| **训练稳定性** | 依赖价值模型质量 | 依赖采样数量 |
| **最适合场景** | 状态空间复杂的任务 | 可验证正确性的任务(数学、代码) |

### 5.1 为什么 GRPO 在 LLM 中有效?

GRPO 特别适合大语言模型的原因:

**1. 奖励可以客观验证**
- 数学题:答案对就是对,错就是错
- 代码生成:运行测试用例即可验证
- 不需要复杂的"价值估计"

**2. 现代 GPU 可以高效并行采样**
- 生成 64 个回答并不比生成 1 个慢太多(批处理)
- 价值模型也是个大模型,内存占用和策略模型一样大

**3. 群组比较更自然**
- 奖励模型通常本身就是通过"比较"训练的(哪个回答更好)
- GRPO 的群组相对比较正好匹配这种训练方式

深入理解 GRPO 强化学习:从 PPO 到 Group Relative Policy Optimization

# 深入理解大模型采样参数：Temperature、Top-p 与 Top-k

当我们与 ChatGPT、Claude 等大语言模型对话时,可能会注意到它们的回答既流畅又富有变化。这背后的关键机制就是**采样策略**。本文将深入浅出地介绍大模型如何生成文本,以及 Temperature、Top-p、Top-k 这三个关键参数如何影响输出结果。

## 一、大模型如何生成 Token?

### 1.1 逐字生成的过程

大语言模型的文本生成是一个**逐个 token 生成**的过程(token 可以简单理解为词或字)。就像我们写作时一个字一个字地思考和书写,模型也是根据前面已经生成的内容,预测下一个最合适的 token。



这个过程可以概括为:

```
输入文本 → 模型编码 → 预测下一个token → 将新token加入输入 → 继续预测...
```

### 1.2 Softmax 前后发生了什么?

让我们具体看看模型内部是如何工作的。假设模型的词汇表有 50,000 个 token(实际中可能更多),生成每个 token 的过程如下:

**Softmax 之前 - Logits(原始分数)**

模型最后一层会输出一个长度为 50,000 的向量,每个位置对应词汇表中一个 token 的**原始分数**(logits)。这些分数没有经过归一化,可能是任意实数。

例如:
```
"苹果" → 8.2
"香蕉" → 3.1
"电脑" → 6.5
"的" → 7.8
"是" → 2.3
...
(共50,000个token)
```

这些原始分数反映了模型认为每个 token 作为下一个词的"合理程度",但它们还不是概率。

**Softmax 之后 - 概率分布**

Softmax 函数将这些原始分数转换为概率分布,使得:
- 所有概率都在 0 到 1 之间
- 所有概率之和等于 1

公式为:

$$P(token_i) = \frac{e^{logit_i}}{\sum_{j=1}^{50000} e^{logit_j}}$$

转换后:
```
"苹果" → 0.352  (35.2%)
"香蕉" → 0.023  (2.3%)
"电脑" → 0.078  (7.8%)
"的" → 0.265  (26.5%)
"是" → 0.011  (1.1%)
...
(概率总和 = 1.0)
```

现在每个 token 都有了明确的被选中概率。但模型并不总是选择概率最高的那个,这就引出了我们的采样策略。

## 二、Temperature:控制创造性的旋钮

Temperature(温度)参数控制概率分布的"平滑程度",从而影响输出的随机性和创造性。

### 2.1 Temperature 的数学原理

Temperature 在 Softmax 之前就开始发挥作用,它会对 logits 进行缩放:

$$P(token_i) = \frac{e^{logit_i/T}}{\sum_{j=1}^{50000} e^{logit_j/T}}$$

其中 T 就是 temperature 参数。

### 2.2 不同 Temperature 值的效果

让我们看看同一组 logits 在不同温度下的变化:

**原始 logits:**
```
"苹果": 8.2, "电脑": 6.5, "的": 7.8, "香蕉": 3.1
```

**Temperature = 1.0(标准情况):**
```
"苹果": 35.2%
"的":   26.5%
"电脑": 7.8%
"香蕉": 2.3%
```

**Temperature = 0.5(更保守):**
```
"苹果": 58.7%  ← 概率进一步集中
"的":   34.1%
"电脑": 3.2%   ← 小概率项被压制
"香蕉": 0.1%
```

**Temperature = 2.0(更随机):**
```
"苹果": 28.3%  ← 概率更平均
"的":   22.1%
"电脑": 12.8%  ← 小概率项机会增加
"香蕉": 5.6%
```

**Temperature → 0(接近贪婪):**
```
"苹果": 99.9%  ← 几乎确定选最高的
"的":   0.1%
"电脑": 0.0%
"香蕉": 0.0%
```

### 2.3 实际应用建议

- **T = 0.0-0.3**: 用于事实性问答、代码生成等需要精确性的任务
- **T = 0.7-1.0**: 平衡创造性和连贯性,适合日常对话
- **T = 1.5-2.0**: 用于创意写作、头脑风暴等需要多样性的场景

## 三、Top-p (Nucleus Sampling):动态筛选候选集

Top-p 采样(也称核采样)是一种更智能的筛选机制,它不是固定选择多少个候选,而是**动态选择累计概率达到 p 的最小候选集**。

### 3.1 Top-p 的工作原理

假设经过 Temperature 调整后,我们得到以下概率分布(按概率降序排列):

```
"苹果": 35.2%
"的":   26.5%
"手机": 12.3%
"电脑": 7.8%
"很":   5.1%
"好":   3.2%
"香蕉": 2.3%
...其他数万个token
```

**如果 Top-p = 0.9:**

1. 从概率最高的开始累加:
   - "苹果": 35.2% (累计: 35.2%)
   - "的": 26.5% (累计: 61.7%)
   - "手机": 12.3% (累计: 74.0%)
   - "电脑": 7.8% (累计: 81.8%)
   - "很": 5.1% (累计: 86.9%)
   - "好": 3.2% (累计: 90.1%) ✓ 超过90%,停止

2. 候选集包含:["苹果", "的", "手机", "电脑", "很", "好"]

3. 将这些候选的概率重新归一化,然后从中随机采样

**如果 Top-p = 0.6:**

只会保留 ["苹果", "的", "手机"],候选范围更小,输出更保守。

**如果 Top-p = 0.95:**

可能包含十几个候选 token,输出更多样。

### 3.2 Top-p 的优势

Top-p 的巧妙之处在于它是**自适应的**:

- 当模型很确定时(某个词概率很高),候选集自动变小
- 当模型不确定时(概率分散),候选集自动变大

这比固定数量的 Top-k 更加灵活智能。

## 四、Top-k:简单直接的截断策略

理解了 Top-p,Top-k 就非常简单了。

### 4.1 Top-k 的工作原理

Top-k 就是**只保留概率最高的 k 个候选**,忽略其他所有选项。

**如果 Top-k = 5:**

```
保留:
"苹果": 35.2%
"的":   26.5%
"手机": 12.3%
"电脑": 7.8%
"很":   5.1%

舍弃:
"好": 3.2%
"香蕉": 2.3%
...其他所有token
```

然后将这 5 个候选的概率重新归一化后采样。

### 4.2 Top-k 的局限性

Top-k 的问题是**不够智能**:

- 无论概率分布如何,都固定选 k 个
- 当某个词概率达到 80% 时,保留其他低概率词反而引入噪声
- 当概率很分散时,k 个候选可能不够

这就是为什么 Top-p 通常更受欢迎。

## 五、三个参数如何协同工作?

在实际应用中,这三个参数通常组合使用:

```
原始logits 
    ↓
应用 Temperature 调整
    ↓
通过 Softmax 得到概率分布
    ↓
应用 Top-p 或 Top-k 筛选候选集
    ↓
从候选集中采样一个 token
```

### 常见配置方案

**1. 精确任务(翻译、代码、数学)**
- Temperature: 0.0-0.3
- Top-p: 0.1-0.5
- 或者直接使用贪婪解码(选概率最高的)

**2. 日常对话**
- Temperature: 0.7-1.0
- Top-p: 0.9-0.95
- 平衡流畅性和多样性

**3. 创意写作**
- Temperature: 1.0-1.5
- Top-p: 0.95-1.0
- 鼓励更多创造性和意外惊喜

## 六、实验:看看参数如何改变输出

让我们用一个例子直观感受这些参数的影响。

**提示词:** "今天天气真好,"

**配置1: Temperature=0.1, Top-p=0.5**
可能输出: "今天天气真好,适合出门散步。"(保守、常见)

**配置2: Temperature=1.0, Top-p=0.9**
可能输出: "今天天气真好,我们去公园野餐吧!"(自然、有变化)

**配置3: Temperature=1.5, Top-p=0.95**
可能输出: "今天天气真好,云朵像棉花糖一样飘在天空中。"(更有创意)

## 总结

- **Token 生成**: 模型逐个预测,通过 Softmax 将原始分数转为概率分布
- **Temperature**: 调整概率分布的"陡峭程度",控制随机性
- **Top-p**: 动态选择累计概率达到 p 的候选集,智能且自适应
- **Top-k**: 固定选择前 k 个候选,简单但不够灵活

理解这些参数,你就能更好地调教大模型,让它在不同任务中发挥最佳表现。记住:没有绝对"最好"的参数设置,关键是根据具体任务和需求进行调整!

tools工作流说明

深入理解 GRPO 强化学习:从 PPO 到 Group Relative Policy Optimization

深入理解大模型采样参数：Temperature、Top-p 与 Top-k

一、大模型如何生成 Token?

1.1 逐字生成的过程