注：本文包含 AI 辅助创作

整体说明

  • 在 2025 年的 LLM RL 研究中，利用 Rubrics（评分细则/量规） 来构建更精细、可解释的奖励函数已经成为主流趋势之一
  • 这种方法主要解决传统标量奖励（Scalar Reward）无法提供细粒度指导的问题
  • 本文总结相关领域具有代表性的论文，论文详细阅读见其他内容

RaR

DR Tulu: Reinforcement Learning with Evolving Rubrics for Deep Research

RubricRL: Simple Generalizable Rewards for Text-to-Text Generation

AdvancedIF: Rubric-Based Benchmarking and Reinforcement Learning for Advancing LLM Instruction

(Rubicon) Reinforcement Learning with Rubric Anchors

(RuscaRL) Breaking the Exploration Bottleneck: Rubric-Scaffolded Reinforcement Learning for General LLM Reasoning

Self-Rewarding Rubric-Based Reinforcement Learning for Open-Ended Reasoning

RLAC: Reinforcement Learning with Adversarial Critic for Dynamic Rubric Generation

PaTaRM: Bridging Pairwise and Pointwise Signals via Preference-Aware Task-Adaptive Reward Modeling

Chasing the Tail: Effective Rubric-based Reward Modeling for Large Language Model Post-Training

Auto-Rubric: Learning to Extract Generalizable Criteria for Reward Modeling

(Self-Rewarding Rubrics) Self-Rewarding Rubric-Based Reinforcement Learning for Open-Ended Reasoning

QA-LIGN: Aligning LLMs through Constitutionally Decomposed QA

AutoRubric-R1V: Rubric-Based Generative Rewards for Faithful Multimodal Reasoning

(DeepSeek-GRM)Inference-Time Scaling for Generalist Reward Modeling

显卡性能详细天梯图

  • 显卡性能天梯图（截止到 24 年底）：
  • H100 SXM 和 H100 性能不一致的原因主要是接口不同导致的，SXM 英伟达设计的一种集成到主板上的接口，支持更大功率，能发挥的显卡性能也更好
  • 图中没有显示的常见显卡简单说明：
    • H800 是 H100 的替代卡，通过降低互联带宽（从 H100 的 900GB/s 降至 450GB/s）规避出口限制，但算力仍达行业顶尖水平
      • 23 年腾讯开始使用
    • H20 是 25年新发布的 H100 限制版芯片，目前有 96G 和 141G 版本，带宽 4TB/s (高于 H100 的 3.35TB/s) 性能大概只有

AI 相关显卡对比

  • 注意：本图来自网络（不一定符合真实情况）
  • 文字总结：
    • 华为
        1. Ascend 910C：A100 的 2.56 倍
        1. Ascend 950DT：A100 的 1.6 倍
        1. Ascend 910B：A100 的 1.026 倍
        1. Ascend 910：A100 的 0.82 倍
    • 寒武纪
        1. Siyuan 690：A100 的 1.8倍
        1. Siyuan 590：A100 的 0.9 倍
        1. Siyuan 290：A100 的 0.82倍
    • 海光
        1. BW100(DCU3)：A100 的 1.12 倍
        1. K100(DCU2)：A100 的 0.32 倍
        1. Z100(DCU1)：A100 的 0.26倍
    • 沐曦
        1. C500：A100 的 0.77 倍
        1. MXN100：A100 的 0.26 倍
    • 壁仞
        1. BR106M/BR106B：A100 的 0.54 倍
        1. BR106C：A100 的 0.41 倍
    • 摩尔线程
        1. MTT S4000：A100 的 0.31 倍
        1. MTT S3000：A100 的 0.1倍。

主要显卡对照记录

  • 主要显卡对照记录表格
    型号 发布时间 架构 主要身份 / 卖点 备注
    H100 2022 年 Q3 Hopper 首款 Hopper 架构旗舰，取代 A100 80 GB HBM3，989 TFLOPS FP16，是 2022 年的“卡皇”
    H800 2023 年 Q1 Hopper 中国特供“缩水版 H100” 带宽砍到 2 TB/s，算力基本保留
    H200 2023-11-13 Hopper H100 的“显存升级版” 141 GB HBM3e + 4.8 TB/s，推理速度大约 2×H100
    H20 2023-11 Ampere（部分文献亦标为 Hopper 降规） 中国特供“再缩水版”，算力只有 H100 的 1/7 96 GB HBM3、148 TFLOPS FP16，对标昇腾 910B
  • 注：H20 虽官方 PPT 仍写 Hopper，但算力/显存规格与 H100/H200 差距过大，业内多视为“Ampere 时代”最后一款中国特供卡
  • H910 系列显卡
    • 亲自测试结论：
      • 910B 约是 H800 的 1/4
      • 910C 约是 H800 的 1/3？

附录：GPU、NPU 和 TPU 辨析

  • NPU（Neural Processing Unit，神经网络处理器）是专门为加速人工智能和深度学习任务设计的硬件芯片
    • NPU 采用针对神经网络算法优化的指令集和硬件结构，如高效矩阵乘法单元、低精度数据处理能力，能以低功耗实现高性能计算，支持边缘智能，可在本地处理数据
    • NPU 主要应用于智能手机、智能安防、自动驾驶、医疗等领域，如手机 AI 拍照、实时人脸识别等
    • 华为的升腾 910B 就是 NPU
  • TPU（Tensor Processing Unit，张量处理单元）是谷歌为加速机器学习工作负载，特别是 TensorFlow 框架下的深度学习任务而定制开发的专用集成电路
    • TPU 采用定制化架构，针对张量运算优化，有高效矩阵乘法单元和专用内存结构，能在较低功耗下实现极高计算性能
    • TPU 主要应用于大规模数据中心的深度学习训练和推理任务
  • GPU（Graphics Processing Unit，图形处理器）是一种专门用于处理图形和图像相关运算的微处理器
    • GPU 拥有大量流处理器，可并行处理多个线程，最初用于图形渲染，如游戏中的3D场景渲染等
    • 因 GPU 强大的并行计算能力，也广泛应用于深度学习、科学计算、影音编辑和渲染等领域

Topic Suggestions for Millions of Repositories

Github官网原文

总体流程图

分为七个步骤：

Readme 预处理与清除

(Readme preprocessing and cleanup)

  • 移除不要的文本块(Remove unwanted blocks)
    • 去除没用文本：一些块是没用的，比如code, table 和image链接等
  • 文本划分(Text segmentation)
    • 提取有用的文本：一个启发式的README tagger，借助格式分析：分析缩进(indentation)，空格(spacing)，和反撇号( `, backtick)等决定是否是有用信息【说明：这里语法分析是没必要的，我们只关心有用的文本，其他的都是为噪音(noise)】
    • 提取到有用文本后，删除拓展部分：HTML标签，路径和其他处理出来的部分等
    • 最后将剩下的文本进行粗粒度分割【用标点符号(punctuation marks)和README中的一些符号，比如临近哈希符号(contiguous hash symbols)】

生成候选主题

(Generate candidate topics)

  • 用自定义的停用词去将词单元划分出来(Use custom stop words to break text into word units)
    • 停用词去除
    • n-gram分段小于等于4(测试发现小于4的比较好，太长的主题过于具体了，不合适)

移除噪音主题

(Eliminate noisy topics)

  • 用逻辑回归模型删减“bad”主题(Use a logistic regression model to prune “bad” topics)
    • 监督逻辑回归模型(supervised logistic regression model)主要针对除了频数比较小的外，一些不好的，比如”great”, “cool”等，这里的模型是一个分类模型，分为两类(good[positive] and bad(negative)) ， 我们称之为关键词过滤模型
      • 手动收集大约300个数据集作为训练集
      • 单个动词一般都是Bad类请教师兄
      • 其他的(Other features we used were occurrence of user names, n-gram size of a phrase, length of a phrase, and numeric content within a phrase.)
      • 以后打算加入回馈机制(来自用户的)去更新这个关键词过滤模型：接受度高的词作为positive的，接受度低的作为停用词或者negative的
  • 移除不满足最小频数的主题(Eliminate topics not satisfying minimum frequency count)

给主题评分

(Score Topics)

  • 用混合tf-idf分数，以主题频率和n元词作为打分标准(Use combination of tf-idf scores, topic frequency and n-gram size for scoring)
    • 评估多种指标后，选择了点互信息指标(PMI)： Pointwise Mutual Information
    • 考虑另一种指标tf-idf：参考论文Using TF-IDF to Determine Word Relevance in Document Queries.pdf或者Python的实现
    • The second approach we tried uses the average tf-idf scores of individual words in a phrase weighted by the phrase frequency (if it’s more than one word long) and n-gram size.
    • 两种方法比较：
      • PMI： 强调独特性，越特殊的短语评分越高，但有些可能只是拼写错误(Typo)或者是没有被删除的代码片段
      • tf-idf： 不强调独特性，最终选择是tf-idf,原因是这个指标较好的平衡了独特性和主题与仓库(repository)的相关程度
    • 在tf-idf的基础上还添加了一下其他的比如boosting scores等方法
    • 下面是TF-IDF的说明*

规范化主题

(Canonicalize topics)

  • 使用内部词典规范主题形式(Use an in-house dictionary to suggest canonical form of topics)

    • 解决文字层面的差别和变化等,比如下面四个主题

      neural-network
      neural-networks
      neuralnetwork
      neuralnetworks

移除相似的主题

(Eliminate near similar topics)

  • 用基于Jaccard相似性评分的贪心算法(Greedy approach using Jaccard similarity scoring)

    • motivation：在得到Top-N的主题后，有些主题其实很相似，虽然都有用，但是他们只是在不同粒度描述了同一个主题而已，因此我们需要删除一些重复的，比如下面的例子

      machine learning
      deep learning
      general-purpose machine learning
      machine learning library
      machine learning algorithms
      distributed machine learning
      machine learning framework
      deep learning library
      support vector machine
      linear regression

    • method： 两个短语的相似性计算使用的是基于词的Jaccard相似性(两个短语的差集与并集的比值，因为它对较短的短语很有效，而且分数是[0-1]的，很方便设置阈值(thresholds))，用贪心算法，如果两个主题相似，去除分数较低的那一个，上面的例子去除相似主题后的结果是：

      machine learning
      deep learning
      support vector machine
      linear regression

返回Top-K主题作为最终结果

Note: 他们都是struct类型的

String

type StringHeader struct {
    Data uintptr
    Len  int
}

Slice

type SliceHeader struct {
    Data uintptr
    Len  int
    Cap  int
}

把Slice转换为String的语法为

[]byte("string")
string([]byte{1,2,3})

注意：这种实现会有拷贝操作

如何避免拷贝操作呢？

答案是自己实现指针转换（也可用反射实现头部转换），省去复制数据部分，同时注意这种实现后底层的数据不能再更改了，不然容易引发错误

直接修改指针类型并构建相应头部

func String2Slice(s string) []byte {
    sp := *(*[2]uintptr)(unsafe.Pointer(&s))
    bp := [3]uintptr{sp[0], sp[1], sp[1]}
    return *(*[]byte)(unsafe.Pointer(&bp))
}

func BytesToString(b []byte) string {
    return *(*string)(unsafe.Pointer(&b))
}

使用反射机制获取到头部再进行转换

func Slice2String(b []byte) (s string) {
    pbytes := (*reflect.SliceHeader)(unsafe.Pointer(&b))
    pstring := (*reflect.StringHeader)(unsafe.Pointer(&s))
    pstring.Data = pbytes.Data
    pstring.Len = pbytes.Len
    return
}


func String2Slice(s string) (b []byte) {
    pbytes := (*reflect.SliceHeader)(unsafe.Pointer(&b))
    pstring := (*reflect.StringHeader)(unsafe.Pointer(&s))
    pbytes.Data = pstring.Data
    pbytes.Len = pstring.Len
    pbytes.Cap = pstring.Len
    return
}

关于引擎

  • 查看各种引擎 show engines;
  • 查看当前默认引擎 show variables like '%storage_engine%';
  • 查看指定表的引擎 show create table tableName;
  • 修改指定表的引擎 alter table tableName engine = innodb;
  • 创建表时指定引擎 create table mytable (id int, titlechar(20)) engine = innodb
  • 修改默认存储引擎
    在mysql配置文件（linux下为/etc/my.cnf），在mysqld后面增加default-storage-engine=INNODB即可

不同引擎的事务支持说明

  • MySQL数据库有多种引擎，一般使用的是InnoDB（从MySQL5.5.5以后，InnoDB是默认引擎），InnoDB存储引擎提供了具有提交、回滚和崩溃恢复能力的事务安全。但是对比Myisam的存储引擎，InnoDB写的处理效率差一些并且会占用更多的磁盘空间以保留数据和索引
  • 其他的引擎不支持事务等，但是存储空间占的比较小，而且操作比较快一些
  • MySQL有多种存储引擎，每种存储引擎有各自的优缺点，可以择优选择使用：MyISAM、InnoDB、MERGE、MEMORY(HEAP)、BDB(BerkeleyDB)、EXAMPLE、FEDERATED、ARCHIVE、CSV、BLACKHOLE
  • 虽然MySQL里的存储引擎不只是MyISAM与InnoDB这两个，但常用的就是两个
    • InnoDB支持事务，MyISAM不支持，这一点是非常之重要。事务是一种高级的处理方式，如在一些列增删改中只要哪个出错还可以回滚还原，而MyISAM就不可以了
  • MyISAM适合查询以及插入为主的应用，InnoDB适合频繁修改以及涉及到安全性较高的应用
  • InnoDB支持外键，MyISAM不支持
  • 从MySQL5.5.5以后，InnoDB是默认引擎
  • InnoDB不支持FULLTEXT类型的索引
  • InnoDB中不保存表的行数，如select count(*) from table时，InnoDB需要扫描一遍整个表来计算有多少行，但是MyISAM只要简单的读出保存好的行数即可。注意的是，当count(*)语句包含where条件时MyISAM也需要扫描整个表
  • 对于自增长的字段，InnoDB中必须包含只有该字段的索引，但是在MyISAM表中可以和其他字段一起建立联合索引
  • 清空整个表时，InnoDB是一行一行的删除，效率非常慢。MyISAM则会重建表
  • InnoDB支持行锁（某些情况下还是锁整表，如 update table set a=1 where user like ‘%lee%’

附录：事务的理解

  • 变量 @@autocommit

    1
    2
    select @@autocommit;
    set @@autocommit = 0;

  • @@autocommit 为0时表示不以显示事务开头的语句或者以事务开头(begin; 或者 start transaction;)都会被缓存起来并且在commit;提交前都可以用rollback;回滚

  • @@autocommit 为1时表示必须以事务开头的语句才会被缓存，否则一个sql语句将会被当做一个事务提交，将不能使用rollback;语句回滚

  • 说明：不是所有引擎都支持事务，常用的支持事务的引擎是InnoDB

关于切片与数组的区别，这里给出定义和传值等使用上的区别，最后给出总结

数组定义

  • 申明类型定义
1
2
var arr [2]byte
arr[0] = 10
  • 直接赋值定义
1
arr := [2]byte{1,2}

切片定义

  • 申明类型定义
1
var sli []byte
  • 直接赋值定义
1
sli := make([]byte, 5)

作为参数传入

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
package main

import "fmt"

func changeSlicePoint(p *[]byte){
	(*p)[0] = 100
}

func changeSlice(a []byte){
	a[4] = 100
}

func changeArrayPoint(p *[5]byte){
	(*p)[0] = 100
}

func changeArray(a [5]byte){
	a[4] = 100
}

func main()  {
	array := [5]byte{1,2,3,4,5}
	var sli1 []byte
	sli1 = make([]byte, 5)
	slice := []byte{1,2,3,4,5}

	changeSlicePoint(&sli1)
	changeSlice(sli1)
	changeArray(array)
	changeArrayPoint(&array)
	changeSlicePoint(&slice)
	changeSlice(slice)

	fmt.Printf("slice[0]: %d\nslice[4]: %d\n", slice[0], slice[4])
	fmt.Printf("sli1[0]: %d\nsli1[4]: %d\n", sli1[0], sli1[4])
	fmt.Printf("array[0]: %d\narray[4]: %d\n", array[0], array[4])
}


//output: 
//slice[0]: 100
//slice[4]: 100
//sli1[0]: 100
//sli1[4]: 100
//array[0]: 100
//array[4]: 5
//

总结

  • 切片传入时是按照引用传递的，加上指针甚至可以修改引用（内存地址）本身

    比如下面的代码会是的传入的引用重新指向nil指针：

1
2
3
4
func changeSlicePoint(p *[]byte){
(*p)[0] = 100
*p = nil
}
  • 数组的传递是按值传递的，使用了指针可实现传入地址，从而实现对数组的修改

本文先给出Go语言中struct类型作为函数参数传入的例子，然后给出总结

首先看下面代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
func changeValue(person Person){
	person.name = "zhoujiahong"
	person.age = 22
}

func changePoint(person *Person){
	person.name = "zhoujiahong"
	person.age = 22
}
func main()  {
	person := Person{
		name:"origin",
	}
	changeValue(person)
	fmt.Printf("Person:\n person.name: %s---person.age: %d\n", person.name, person.age)
	changePoint(&person)
	fmt.Printf("*Person:\n person.name: %s---person.age: %d\n", person.name, person.age)
}

//output:
//Person:
// person.name: origin---person.age: 0
//*Person:
// person.name: zhoujiahong---person.age: 22

总结

  • struct类型的传递是按值传递的，与数组[5]byte等的传递相似，也可以理解为和C++一样
  • struct类型传递与切片不同，切片事实上是一个指针（栈）指向一块数组（堆）这样的数据结构，所以无论如何都是传入指针或者是指针（栈）的指针（指向栈）
  • 可以理解为: 切片类似于Java（切片还多了个特色，通过传入切片可以修改指针（栈）本身，而Java是做不到的）， 而数组类似于C++

注意：struct类型与切片传值方式不同而与数组相同

Welcome to Hexo! This is your very first post. Check documentation for more info. If you get any problems when using Hexo, you can find the answer in troubleshooting or you can ask me on GitHub.

Quick Start

Create a new post

1
$ hexo new "My New Post"

More info: Writing

Run server

1
$ hexo server

More info: Server

Generate static files

1
$ hexo generate

More info: Generating

Deploy to remote sites

1
$ hexo deploy

More info: Deployment

Hexo 项目文件目录说明归纳整理

./package.json

这个文件指定了hexo框架的参数和依赖插件

./package-lock.json

package.json里面定义的是版本范围（比如 1.0.0），具体跑npm install的时候安的什么版本，要解析后才能决定，这里面定义的依赖关系树，可以称之为逻辑树（logical tree）。

node_modules文件夹下才是npm实际安装的确定版本的东西，这里面的文件夹结构我们可以称之为物理树（physical tree）。安装过程中有一些去重算法，所以你会发现逻辑树结构和物理树结构不完全一样。

package-lock.json可以理解成对结合了逻辑树和物理树的一个快照（snapshot），里面有明确的各依赖版本号，实际安装的结构，也有逻辑树的结构。其最大的好处就是能获得可重复的构建（repeatable build），当你在CI（持续集成）上重复build的时候，得到的artifact是一样的，因为依赖的版本都被锁住了。在npm5以后，其内容和npm-shrinkwrap.json一模一样

./scaffolds

scaffolds是“脚手架、骨架”的意思，当你新建一篇文章（hexo new ‘title’）的时候，hexo是根据这个目录下的文件进行构建的。scaffolds模版 文件夹。Hexo的模板是指在新建的markdown文件中默认填充的内容。例如，如果您修改scaffold/post.md中的Front-matter内容，那么每次新建一篇文章时都会包含这个修改

./source

source 资源文件夹是存放用户资源的地方。除 _posts 文件夹之外，开头命名为 _ (下划线)的文件 / 文件夹和隐藏的文件将会被忽略。Markdown 和 HTML 文件会被解析并放到 public 文件夹，而其他文件会被拷贝过去

./source/_posts

需要新建的博文都放在 _posts 目录下。_posts 目录下是一个个 markdown 文件。你应该可以看到一个 hello-world.md 的文件，文章就在这个文件中编辑。_posts 目录下的md文件，会被编译成html文件，放到 public （此文件现在应该没有，因为你还没有编译过）文件夹下

./themes

网站主题目录，hexo有非常好的主题拓展，支持的主题也很丰富。该目录下，每一个子目录就是一个主题。
More info: hexo主题

./_config.yml

_config.yml 采用YAML语法格式，具体语法在这里
具体配置可以参考官方文档，_config.yml 文件中的内容，并对主要参数做简单的介绍

./public

public 生成的网站文件，发布的站点文件

./tag

tag 标签文件夹

Hexo命令归纳整理

init

hexo init [folder]

# 在cmd命令下，cd到你所需要建立博客的文件夹，执行此命令，其中folder为可选指令，若不写，则默认当前目录

hexo new

hexo new [layout] \<title\>

#layout为可选项，默认使用_config.yml中的default_layout。新建文章的指令

generate

hexo generate

# 生成静态文件，

# 可选参数：

-d ,–deploy 文件生成后立即部署网站

-w , –watch 件事文件变动

deploy

hexo deploy

# 发布到网站，这里就是发布到 _config.yml中deploy中设置的网址上。

# 参数

-g , –generate 部署前生成静态文件

npm install

每一个rn项目都有一个package.json文件，里面有很多组件信息，使用npm install将按照package.json安装所需要的组件放在生成的node_modules文件夹中，rn项目下的每一个文件中都可以通过import引入node_modules的组件来加以使用

hexo clean

hexo clean 清除缓存文件(db.json)和已生成的静态文件(public)，通常更换主题后，无效时，可以运行此命令

hexo server

hexo server

# 启动server，就可以在本地预览效果。

#参数，默认网址http://localhost:4000/

-p , –port 重设端口

-s , –static 只是用静态文件

-l , –log 启动日志记录，使用覆盖记录格式

-i , –ip 重新制定服务器ip