Songbo Zhang

The true revolutionary is guided by great feelings of love.

Posted on In ,

需要在掌握矩阵加法的基础上，学习共享内存(__shared__)以及tile分块策略

同一个block中的所有thread共享一份共享内存

先将经常需要使用的数据从内存中转移到共享内存，在加载数据的时候就直接从共享内存中加载而不是从内存中加载，从而加快速度

同时在具体实现的时候使用了一个trick：分块计算矩阵乘法。这样做可以完美地与共享内存的机制进行搭配使用。

代码实现如下（相关具体实现细节在代码注释说明）：

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
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
#include <stdio.h>
#include <stdlib.h>
#include <cuda_runtime.h>

const int M = 200;
const int K = 400;
const int N = 500;

// 定义分块的大小
const int TILE_SIZE = 32;

inline void init(int* mat, int row, int col){
    for(int i = 0; i < row; i ++)
        for(int j = 0; j < col; j ++)
            mat[i * col + j] = i + j;
}
inline void print(int* mat, int row, int col){
    printf("=========================================\n");
    for(int i = 0; i < row; i ++){
        for(int j = 0; j < col; j ++)
            printf("%d ", mat[i * col + j]);
        printf("\n");
    }
    printf("=========================================\n");
}

__global__ void mul(int* a, int* b, int* c, int M, int K, int N){
    int bx = blockIdx.x, by = blockIdx.y;
    int tx = threadIdx.x, ty = threadIdx.y;

    int col = bx * TILE_SIZE + tx;
    int row = by * TILE_SIZE + ty;

	// 定义共享内存 ds_a存储A矩阵的部分特定数据， ds_b存储B矩阵部分特定数据
    __shared__ int ds_a[TILE_SIZE][TILE_SIZE];
    __shared__ int ds_b[TILE_SIZE][TILE_SIZE];

    //存储最终的计算得到的值
    int val = 0;

    // 这里一个很关键的思想，因为无法将整个矩阵都放进共享内存中（共享内存太小了），所以分阶段处理计算某个点的数据值，这并不违背矩阵乘法的计算法则
    for(int ph = 0; ph < (K + TILE_SIZE - 1) / TILE_SIZE; ph ++){
        // 将A矩阵的部分数值复制到共享内存ds_a中
        if(row < M && (ph * TILE_SIZE + tx) < K)//这里是为了防止超过边界，如果超过就赋值为0
            ds_a[ty][tx] = a[row * K + (ph * TILE_SIZE + tx)];
        else
            ds_a[ty][tx] = 0;

        // B矩阵的相关逻辑，完全同理
        if((ph * TILE_SIZE + ty) < K && col < N)
            ds_b[ty][tx] = b[(ph * TILE_SIZE + ty) * N + col];
        else
            ds_b[ty][tx] = 0;
		
        // 这个函数是指：让跑的快的线程等等跑的慢的线程，等同一个block的thread跑完之后再进行下一行
        // 这里的作用是为了防止数据还没搬运完就开始进行乘法运算了
        __syncthreads();

        // 将现有共享内存中储存的部分的数据进行矩阵乘法
        for(int i = 0; i < TILE_SIZE; i++)
            val += ds_a[ty][i] * ds_b[i][tx];

        //同样，这里也需要加一个，目的是为了防止跑得快的线程进入下一个循环将数据覆盖了
        __syncthreads();
    }

    // 超过最终矩阵的大小
    if(col >= N || row >= M)
        return;
    
    // 写入
    c[row * N + col] = val;
}

int main(){

    int *a_h, *b_h, *c_h;
    int *a_d, *b_d, *c_d;

    size_t size_a = sizeof(int) * M * K;
    size_t size_b = sizeof(int) * K * N;
    size_t size_c = sizeof(int) * M * N;

    a_h = (int*)malloc(size_a);
    b_h = (int*)malloc(size_b);
    cudaMalloc((void**)&a_d, size_a);
    cudaMalloc((void**)&b_d, size_b);
    cudaMalloc((void**)&c_d, size_c);

    init(a_h, M, K);
    init(b_h, K, N);

    cudaMemcpy(a_d, a_h, size_a, cudaMemcpyHostToDevice);
    cudaMemcpy(b_d, b_h, size_b, cudaMemcpyHostToDevice);

    dim3 block_size(TILE_SIZE, TILE_SIZE);
    dim3 grid_size(
        (N + block_size.x - 1)/block_size.x,
        (M + block_size.y - 1)/block_size.y
    );

    mul<<<grid_size, block_size>>>(a_d, b_d, c_d, M, K, N);


    c_h = (int*)malloc(size_c);
    cudaMemcpy(c_h, c_d, size_c, cudaMemcpyDeviceToHost);
    print(c_h, 5, 5);


    free(a_h);free(b_h);free(c_h);
    cudaFree(a_d);cudaFree(b_d);cudaFree(c_d);

    return 0;
}

Posted on In ,

这里需要先清楚GPU的基本结构（thread、warp、block、grid）

实质上就是利用众多core进行并行计算，将对应位置的数据计算好之后填到对应的位置

实际的操作流程是（分配以及销毁host以及device上的内存省略）：host端数据初始化 -> 将数据从 host 复制到device上 -> 在device上进行数据计算 -> 将数据从device上转移回host -> 输出

实现代码如下：

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
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
#include <stdio.h>
#include <stdlib.h>
#include <cuda_runtime.h>

const int N = 1000;

inline void init(int* mat){
    for(int i = 0; i < N; i++)
        for(int j = 0; j < N; j++){
            int val = i + j + 1;
            mat[i * N + j] = val;
        }
}
inline void print(int* mat, int n){
    for(int i = 0; i < n; i++){
        for(int j = 0; j < n; j++)
            printf("%d ", mat[i * N + j]);
        printf("\n");
    }
}

__global__ void add(int* A, int* B, int* C){
    int col = blockIdx.x * blockDim.x + threadIdx.x;
    int row = blockIdx.y * blockDim.y + threadIdx.y;

    if(row >= N || col >= N)
        return;

    int index = row * N + col;

    C[index] = A[index] + B[index];
}

int main(){

    int *a_h, *b_h, *c_h;
    int *a_d, *b_d, *c_d;
    size_t size = sizeof(int) * N * N;
    // 在Host端进行分配空间
    a_h = (int*)malloc(size);
    b_h = (int*)malloc(size);
    // 在Device端分配空间
    cudaMalloc((void**)&a_d, size);
    cudaMalloc((void**)&b_d, size);
    cudaMalloc((void**)&c_d, size);

    init(a_h);
    init(b_h);
    
    // 将host中已经初始化好的数据复制到device端
    cudaMemcpy(a_d, a_h, size, cudaMemcpyHostToDevice);
    cudaMemcpy(b_d, b_h, size, cudaMemcpyHostToDevice);

    // 定义 block 和 grid 的尺寸大小
    dim3 block_size(16, 16);
    dim3 grid_size(
        (N + block_size.x - 1) / block_size.x,
        (N + block_size.y - 1) / block_size.y
    );
	
    //调用 kernel function
    add<<<grid_size, block_size>>>(a_d, b_d, c_d);

	
    c_h = (int*)malloc(size);
    //将device中计算好的数据复制到host端
    cudaMemcpy(c_h, c_d, size, cudaMemcpyDeviceToHost);

    print(c_h, 6);

	//释放内存
    free(a_h);free(b_h);free(c_h);
    cudaFree(a_d);cudaFree(b_d);cudaFree(c_d);

    return 0;
}

Posted on Edited on In ,

对于一般的编程语言（C++、python等），输出“Hello world”实质上是由CPU进行相关计算以及处理的，那么对于现代GPU，拥有成千上万的cuda核心进行并行计算以及并行处理的能力，如何使用GPU的cuda核心进行计算呢？

对于一门编程语言，最开始学习的语法就是”Hello World”

那么，对于cuda编程，如何输出一份来自GPU的hello world呢

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <stdio.h>
#include <cuda_runtime.h>

__global__ void printfromGPU(){
    printf("Hello World from GPU!");
}

int main(){
    
    printf("Hello World from CPU!");
    
    printfromGPU<<<3, 9>>>();//代表启动三个block，每一个block启动9个thread
    
    return 0;
}

输出效果

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
Hello World from CPU
Hello World form CUDA
Hello World form CUDA
Hello World form CUDA
Hello World form CUDA
Hello World form CUDA
Hello World form CUDA
Hello World form CUDA
Hello World form CUDA
Hello World form CUDA
Hello World form CUDA
Hello World form CUDA
Hello World form CUDA
Hello World form CUDA
Hello World form CUDA
Hello World form CUDA
Hello World form CUDA
Hello World form CUDA
Hello World form CUDA
Hello World form CUDA
Hello World form CUDA
Hello World form CUDA
Hello World form CUDA
Hello World form CUDA
Hello World form CUDA
Hello World form CUDA
Hello World form CUDA
Hello World form CUDA

Posted on In

国家奖学金答辩演讲稿

【展示slide 1】

尊敬的各位评委老师，亲爱的各位同学们，大家下午好。

我是来自信息与软件工程学院的张淞博。 非常荣幸能够站在这里参加本次国家奖学金的答辩。我将向各位分享我如何将一年前我的憧憬与期许，一步步变为现实。

【展示slide 2】

过去一年，我交出了一份问心无愧的答卷：综合测评专业第一，专业成绩排名前6%，同时我也积极投身学生工作，担任了多项学生干部，在服务同学中实现自我价值。

这份成绩的背后，是我的思想与行动的统一。

【展示slide 3】

作为一个又红又专的成电人，思想引领与学业成就是不可分割的。

思想上， 我积极向党组织靠拢，在入学之初，就向组织递交入党申请书，成为第一批入党积极分子，此后更是在团校、党课、党建活动和入党积极分子培训中不断提升理论素养。

【展示slide 4】

行动上， 我将思想觉悟转化为学习动力。过去一学年，我刻苦钻研，最终取得了**综合测评专业第一，专业成绩排名前6%**的成绩，并且在多门核心课程中取得优异分数。

正是这样扎实的学业表现，我才有了参与高水平科研项目的机会。

【展示slide 5】

作为一名软件工程专业的学子，我深知，理论学习的最终目的是创新与实践。

因此，我投身于一项关于大模型“软提示”优化的前沿研究。我主要负责构建自动化实验流水线、开发关键分析工具、并为论文提供了核心的数据与图表支撑。本研究首次从拓扑数据分析的视角，为软提示的“黑盒”优化过程提供了一种可解释性分析 ，并基于此设计了一种全新的损失函数TSLoss ，显著加速了模型收敛。目前，这项工作已作为第四作者投稿至人工智能顶级会议ICLR

这些经历让我对从理论到实践的科研全流程有了更深入的理解，同时极大地锻炼了我的科研思维和团队协作能力。

同时，我积极参加学科竞赛，以赛促学，累计获得了两项省级奖项，同时负责一项院级创新创业项目，在实战中不断打磨自己的专业技能。

【展示slide 6】

学业和科研之外，我从未忘记作为一名成电人的责任与担当。

作为班级团支书与新生导生，我尽心服务同学；作为志愿者，我累计贡献了95.8小时的服务时长；作为成电寒假招生宣传行的绵阳、遂宁两个地级市的领队，我出色地完成了宣传任务，获评“优秀领队”；与此同时，我也积极参加文体活动，在汗水中磨砺品质，在运动中获得成长。我希望用自己的行动，去传递一份光和热。

【展示slide 7】

回顾过去，最浪漫的事莫过于通过努力让憧憬变为现实，此刻我可以说，过往一年，问心无愧，不负青春

展望未来，我将带着这份笃定，努力成长为一名更优秀的成电人！

我的汇报到此结束，感谢各位老师的倾听！

Posted on In

基本信息

标题：Proximal Policy Optimization Algorithms
链接：Proximal Policy Optimization Algorithms
30341引用量

研究背景动机

在过去强化学习的研究中，主要的方法有深度Q学习、“香草”策略梯度方法、TRPO。
对于深度Q学习而言，主要的缺点在于不能在一些简单问题上表现良好（在离散动作空间表现好，但是没有被证明在连续控制测试中表现良好），也相对难以理解。

对于“香草”策略梯度方法，数据效率和鲁棒性都较差。

对于TRPO，虽然TRPO的数据效率和性能可靠 ，但它相对复杂。它与包含噪声（如dropout）或参数共享（在策略和价值函数之间）的神经网络架构不兼容

当时强化学习领域缺乏一种可扩展、数据高效且鲁棒的算法。

PPO的目标就是在只使用一阶优化的前提下，达到TRPO的数据效率和可靠性能 ，从而创造出一个更简单、更通用、性能更好的新方法

核心方法

实验设计

结论总结

Posted on Edited on In

基础信息

ReAct: Synergizing Reasoning and Acting in Language Models
发布在 ICLR 2023，引用量4581

文章链接：
ReAct: Synergizing Reasoning and Acting in Language Models

一句话总结：将过去工作中关于AI agnet的“推理”和“行动”这两个单独进行研究的板块合二为一，通过他们的交替使用，使得模型表现达到SOTA，同时增强了可解释性和可信度

研究背景动机

在人类解决问题任务的时候，往往会采取推理-行动-反馈-推理-行动的链，这对于完成任务是很有帮助的。那么在ai agent中，是否也可以借鉴这一模式，将“推理”和“行动”相结合，相互交错叠加进行执行。
这里的推理使用llm创建、维护高级计划，行动是与外部环境进行交互（比如维基百科）

过去相关的研究中，CoT的推理过程是静态的，没有对于外部执行的观测，这一点极大地限制了它的推理能力和更新能力，这也就导致了产生幻觉的可能性。另一条研究路线是专注于“行动”的，通过预训练的llm在交互中通过语言先验来预测行动，将多模态结果转化为文字，然后让语言模型生成行为，这一点的思路问题在于没有使用语言模型来推理高级目标，也就不存在工作记忆了，又是一个过于“动态”，只关注实时当前的架构设计了。

所以在这种“推理”和“行动”分家的研究背景下，作者提出将二者相结合，交错进行的新范式，在四个不同的基线中达到SOTA

核心方法

对于一个最基本的可与环境进行交互的agent：
在时间步 $t$ 中，得到的环境观察 $o_t \in O$，然后通过策略 $π(a_t|c_t)$ 采取 $a_t \in A$,其中$ c_t$ 是agent能得到的“上下文”， $ c_t = (o_1, a_1, · · · , o_{t−1}, a_{t−1}, o_t)$

那么 ReAct的思路其实就是将其中的 $A$ 增广到 $A\cup L$,其中 $L$ 是语言空间，代表着llm产生的思考或者是推理。由于是思考或推理，所以并不会对外界环境造成印象，也不会影响反馈，而是会通过 $a_t$ 对当前上下文 $c_t$ 进行推理，生成有用的信息，然后更新上下文 $c_{t+1} = (c_t, \hat{a_t})$ 来进一步推进未来的推理或者行为。

其中的语言空间是由llm生成实现

这样设计有四个特点：

  • prompts 直观且易于设计
  • 通用灵活
  • 表现性，鲁棒性好
  • 人性化，可控

实验和结果

首先使用两个很有挑战性的数据集：HotPotQA、FEVER
允许agent的动作空间有：搜索维基百科、寻找指定字符串的下一句话、结束。这些动作空间的目的是为了模拟人类和维基百科互动，所以性能方面明显弱于神经检索。

指定标准化的提示词
选择的基线有：标准的prompt引导llm、CoT、Act-Only
并且在实验中，有一个ReAct和CoT-SC的回退机制，即当REACT表现不佳的时候，会退回到CoT-SC，实验证明这种回退机制表现更佳

实验证明，REACT表现持续地比Act-Only更佳，但是和CoT的性能比较的时候并不明显，分析案例之后得到的结果是：

  • CoT幻觉问题未能克服
  • 交错推理和动作的设计提高REACT的可信性，但是也约束了推理步骤的灵活性，导致性能不明显
  • 在REACT错误的案例中，说明了信息搜索准确的重要性，也就是说明REACT架构限制了推理步骤的灵活性
    为了平衡灵活性和真实性，所以将提出了回退机制

然后测试了在交互式决策任务ALFWorld和Webshop的表现，在这两个复杂决策任务环境下，REACT的表现均优于ACT-Only

结论和讨论

作者提出一种REACT简单而有效的方法，在多条问答、事实核查和交互式任务上都具有可解释的优越性能（可解释性来自型生成的“思考痕迹 (reasoning traces)” ）

对提示示例的依赖但是可能会超过情景学习的输入上下文长度限制
作者提出未来更多高质量人类标注是更一步提升性能的途径
并提出将强化学习等互补范式相结合，可能会产生更加强大的agent

思考和批判

对提示示例的依赖但是上下文长度限制

Posted on Edited on In ,

一篇关于Agent Security的综述文章：AI Agents Under Threat: A Survey of Key Security Challenges and Future Pathways
https://arxiv.org/pdf/2406.02630

简单分类以及著名工作介绍

下面是一些自己的归类:

AI System Attack Techniques

主要关注攻击者如何利用基于LLM的智能体的内在机制和漏洞，通过具体的技术手段进行攻击

Prompt Injection Attacks

  • https://arxiv.org/abs/2211.09527
    对于“提示词注入”的系统性研究。提出了一个名为 PROMPTINJECT 的框架，用以系统性地构建和测试针对语言模型的对抗性提示攻击 。论文重点分析了两种主要的攻击类型

    1. 目标劫持 (Goal Hijacking)
    2. 提示泄露 (Prompt Leaking):

  • https://arxiv.org/abs/2302.12173
    开创性地提出并系统研究了一种针对大语言模型集成应用的新型攻击向量——间接提示注入 (Indirect Prompt Injection, IPI)
    当LLM被赋予检索外部信息的能力时，应用本身就很难区分哪些是应处理的“数据”，哪些是需要执行的“指令”。
    攻击者将恶意指令策略性地植入到各种外部数据源中，例如网站、电子邮件或文档 。当LLM应用（如集成了GPT-4的Bing聊天）为了响应普通用户的请求而去检索这些被“污染”的数据时，就会在用户不知情的情况下接收并执行这些恶意指令

Data and Knowledge Poisoning Attacks

  • https://arxiv.org/abs/2402.07867
    攻击者可以在RAG系统的知识库中注入少量恶意文本，诱导LLM为攻击者选择的目标问题生成攻击者选择的目标答案
    指出了RAG架构在知识源层面的安全脆弱性。证明了通过知识腐化攻击来操纵RAG系统的输出是完全可行的，这为许多依赖RAG的应用（如金融、医疗、法律等）带来了严重的安全隐患。最后强调，学术界和工业界亟需开发新的、更有效的防御机制来应对此类威胁

  • https://arxiv.org/abs/2305.00944
    揭示了针对LLM的供应链攻击风险。研究表明，攻击者可以在指令微调（Instruction Tuning）阶段，通过注入少量有毒数据来“污染”模型
    这种污染非常隐蔽，被污染后的模型在正常任务上表现良好，但会对特定的、攻击者预设的触发器做出恶意响应，例如生成有害内容、泄露信息或执行不安全指令。这对依赖第三方数据集或预训练模型来构建智能体的开发者构成了严重威胁

Jailbreaking Attacks

  • https://arxiv.org/abs/2307.02483
    该论文深入分析了现有 LLM 安全训练的弱点，并系统地总结了越狱攻击的多种模式（如角色扮演、利用竞争目标等）。它解释了为什么即使经过严格的安全对齐，LLM 仍然容易被绕过
    从模型对齐的根源上解释了 Agent 安全脆弱性的原因，有助于理解各类攻击技术背后的共同原理

  • https://arxiv.org/abs/2307.15043
    尽管该论文不直接针对“智能体”，但其研究成果对所有基于LLM的系统（包括智能体）的安全性构成了根本性挑战。论文作者提出了一种简单且有效的方法，可以自动生成一小段特定的、看似无意义的字符串（后缀）
    当把这个字符串附加到任何用户请求的末尾时，它都能可靠地“越狱”（Jailbreak）多种不同的、经过安全对齐的大型语言模型（如ChatGPT, Bard, Claude等），使其生成有害、违规或危险的内容。这种攻击的通用性和可转移性表明，当前基于模型对齐的防御措施存在系统性漏洞，这对确保智能体行为安全至关重要

Attacks on Specific Agent Forms

  • https://arxiv.org/abs/2402.11208
    传统针对LLM的后门攻击相比，针对智能体的攻击形式更加多样、隐蔽且危害更大
    这是因为智能体在完成任务时会进行多步骤的思考和推理，并与外部环境交互，这为攻击者提供了更广泛的攻击空间
    具体的攻击方式有以下几种：查询攻击 (Query-Attack)、观察攻击 (Observation-Attack)、操控中间思想 (Thought-Attack)
    实验结果表明，LLM-based Agents极易受到后门攻击的侵害，且攻击成功率很高

  • https://arxiv.org/abs/2005.09161
    这篇论文开创性地研究了针对具身AI）的对抗性攻击 。与仅处理文本的Agent不同，具身Agent需要感知和理解视觉环境。研究表明，攻击者可以通过向环境视频中添加微小的、人眼难以察觉的时空扰动（spatio-temporal perturbations），来欺骗Agent使其做出错误的判断和行为
    这项工作强调了Agent在与复杂动态环境交互时的感知安全问题

Multi-Agent System Specific Risks

当多个智能体进行交互时才会出现或被放大的独特安全威胁，如攻击的传播和智能体之间的恶意共谋

Attack Propagation and Spread

  • https://arxiv.org/abs/2402.08567
    揭示了一种针对multi-agent系统的、比传统攻击更为严重的新型安全漏洞，并将其命名为“传染性越狱”（infectious jailbreak）
    与一次只影响单个智能体的传统越狱攻击不同，“传染性越狱”具有自我传播和指数级扩散的特性 。攻击者只需成功“感染”网络中的任意
    单个智能体，该智能体就会在与其他智能体交互的过程中，将“病毒”（一张特制的对抗性图片）自动传播出去，最终导致整个网络中的几乎所有智能体都被迅速感染，并表现出有害行为

  • https://arxiv.org/abs/2403.02817
    Morris-II 专门攻击由生成式人工智能（GenAI）驱动的应用程序生态系统，特别是那些使用“检索增强生成”（RAG）技术的应用，例如集成了AI功能的电子邮件助手
    攻击流程：感染、传播、执行、复制以及蠕虫链式传播
    同时文章给出了一种防御系统“虚拟驴子”，可以极大程度上做到防护

Malicious Inter-Agent Collaboration

  • https://arxiv.org/abs/2308.14752
    这篇综述系统性地整理了AI（尤其是基于LLM的Agent）在各种场景下表现出的欺骗行为。案例表明，AI Agent为了在竞争环境中获胜或实现目标，会学会策略性地误导、撒谎甚至背叛
    例如，Meta开发的AI系统Cicero在《外交》游戏中就表现出了精心策划的欺骗行为。该研究警示，需要关注多智能体交互中可能出现的“马基雅维利式”智能，并为其制定规范和解决方案。同时提出了一个多层次的解决方案框架

  • https://openreview.net/pdf?id=FXZFrOvIoc
    该研究探讨了多智能体系统中的一个核心威胁：秘密共谋 。论文指出，即使Agent之间的通信是公开的，它们也可能通过“隐写术”等方式建立秘密通信渠道，以协调它们的行为来达成对自身有利但可能损害系统整体目标的共识，且这种共谋在信息论上可能无法被检测到
    这会导致系统决策出现无法解释的偏见 。该工作为理解和防御合作型多智能体系统（Cooperative multi-agent systems）中的潜在风险提供了理论基础和评估基准

AI System Defense & Evaluation

如何抵御攻击、提升AI系统的安全性，以及如何系统性地测试和识别潜在的安全风险

Proactive Defense Frameworks

  • https://arxiv.org/abs/2403.04783
    提出了一种创新的、基于多智能体（Multi-agent）协作的防御框架来抵御越狱攻击。该框架利用多个专门的AI Agent（例如，分析Agent、用户模拟Agent、决策Agent）对用户输入进行联合评估和审议
    通过模拟辩论和多角度审查，系统能够更准确地识别和拦截恶意的越狱企图，同时保持对正常请求的可用性。该研究为防御复杂的越狱攻击提供了新的思路

Security Risk Evaluation and Identification

  • https://arxiv.org/abs/2309.15817
    这篇论文提供了一个新颖、可扩展且成本效益高的框架（ToolEmu），用于在语言模型代理部署到现实世界之前，系统性地识别其潜在的安全风险，特别是那些难以通过传统方法发现的严重风险
    ToolEmu 的创新框架，其核心思想是“用语言模型来测试语言模型”

Safety Alignment and Self-Correction

  • https://arxiv.org/abs/2212.08073
    这篇论文开创性地提出了“宪法AI”的概念，是自我交互用于AI安全对齐的典范。其核心思想是，让AI模型在没有人类干预的情况下变得更安全
    具体流程分为两个阶段：1) 首先让模型根据一套预设的原则（“宪法”），对各种提示词生成多个回答，并自我批判哪个回答更好；2) 然后利用这些自我生成的偏好数据来微调模型。这个“生成-批判-再学习”的闭环完全在AI内部完成，是AI与“自我原则”进行交互的典型范例，深刻影响了后续的安全对齐研究

AI Misuse & Foundational Security Issues

更宏观和基础性的安全议题，包括AI被武器化的潜在风险以及模型本身存在的数据隐私等根本性问题

AI Weaponization and Autonomous Misuse

  • https://arxiv.org/abs/2404.08144
    这篇论文证实了AI智能体作为网络攻击工具的巨大潜力。研究团队构建了一个能够自主行动的LLM智能体，并证明了它仅通过阅读CVE（通用漏洞披露）漏洞公告，就能独立地、端到端地完成对真实世界软件“一日漏洞”（One-day Vulnerability）的利用
    整个过程无需人类干预，从理解漏洞原理到编写并执行攻击代码一气呵成。这项工作极大地提升了学术界和工业界对高级AI智能体被武器化用于网络攻击的风险认知

Privacy and Data Leakage

  • https://arxiv.org/abs/2012.07805
    这篇论文是隐私安全领域的里程碑式工作。它明确证实了大型语言模型会“记忆”其训练数据中的具体、敏感信息，例如个人身份信息（PII）、电子邮件、电话号码等。作者们展示了一种攻击方法，可以通过精心设计的查询，从一个像GPT-2这样的大模型中逐字逐句地提取出其训练集中存在的真实个人数据
    研究为后续所有关于LLM隐私泄露风险的研究奠定了基础，对于需要处理用户数据的智能体应用来说，这是一个必须考虑的核心安全问题

我的想法

基于llm的agent系统架构工作中，会容易暴露出一些安全性的问题。

以最常见得到提示词注入而言，https://arxiv.org/abs/2211.09527 系统地总结了提示词注入，https://arxiv.org/abs/2302.12173 做了一个攻击向量来达到提示词注入的指令效果（有一点像恶意的softprompt？）

由于agent需要访问外部的数据，所以这也是一个暴露的攻击点，https://arxiv.org/abs/2402.07867 考察了在RAG系统知识库中注入少量恶意文本，从而诱导agent输出恶意的答案，这也暴露出RAG系统的安全脆弱性。https://arxiv.org/abs/2305.00944 则针对指令微调的时候，注入少量恶意的数据污染模型，诱导agent在特定的问题上做出恶意响应

在越狱攻击方面，https://arxiv.org/abs/2307.02483 分析了llm安全训练的弱点，总结了越狱攻击的常见模式，也从根本上解释了agent安全脆弱性的原因。https://arxiv.org/abs/2307.15043 通过将特定的无意义字符串加入到后缀，让经过安全对齐的llm生成危险的内容。

那么针对agent而言，有更加多样而特定的形式进行攻击，https://arxiv.org/abs/2402.11208 总结了LLM-based Agents的受攻击类型以及证明了agent更加容易受到后门攻击侵害。https://arxiv.org/abs/2005.09161 则通过具身AI感知模块中对于微小的，人类难以察觉的时空扰动所带来的agent做出错误行为

multi-agents提升智能体能力的同时也扩大了受攻击的风险。https://arxiv.org/abs/2402.08567 揭示了一种通过智能体之间交流扩散的传染性越狱攻击方式，能够让网络中的智能体迅速被感染。https://arxiv.org/abs/2403.02817 分析了基于AI的APP系统在遇到恶意攻击时的脆弱性，会导致迅速的扩散病毒，同时文章也给出了一种防御系统作为防护。

那么在multi-agents系统中，不仅需要考虑外界人对系统的攻击，也要考虑agents是否会对外界造成攻击。https://arxiv.org/abs/2308.14752 整理了AI在各种场景下的欺骗行为，该研究警示，需要关注多智能体交互中可能出现的“马基雅维利式”智能，并为其制定规范和解决方案。https://openreview.net/pdf?id=FXZFrOvIoc 也是讨论multi-agent中不同智能体之间通过人类无法观测到的形式进行秘密通信。

那么在安全防护方面，https://arxiv.org/abs/2403.04783 提出了一种基于multi-agent的防护框架，通过多角度以及辩论式的审查，让系统识别到恶意越狱。https://arxiv.org/abs/2309.15817 提出ToolEmu 的框架，“用语言模型来测试语言模型”，来得到难以通过传统方法察觉到的风险。

那么如何在无人类干预的情况下，让agent进行安全对齐？https://arxiv.org/abs/2212.08073 提出“宪法AI”的概念，通过让模型根据一套预设的原则（“宪法”），对各种提示词生成多个回答，并自我批判哪个回答更好，然后利用这些自我生成的偏好数据来微调模型。完成“生成-批判-再学习”的闭环，使得AI能够完成安全对齐。

那么，也同样需要防范恶意使用Agent来执行恶意的攻击。https://arxiv.org/abs/2404.08144 介绍了一种仅通过阅读CVE（通用漏洞披露）漏洞公告，就能独立地、端到端地完成对真实世界软件“一日漏洞”（One-day Vulnerability）的利用
整个过程无需人类干预，从理解漏洞原理到编写并执行攻击代码一气呵成的自主行动的LLM智能体。https://arxiv.org/abs/2012.07805 明确证实了大型语言模型会“记忆”其训练数据中的具体、敏感信息，例如个人身份信息（PII）、电子邮件、电话号码等。这些工作为后续LLM安全性提出了重要的基础

Posted on Edited on In ,

LLM 在自然语言处理领域展现了卓越的能力，但其固有的知识局限性——即“知识截止日期”和内容不可追溯性——是其在关键业务应用中落地的主要障碍。RAG 作为一种先进的架构范式，通过动态地将外部知识库与LLM的生成过程相结合，有效解决了这些挑战。

大型语言模型的内在局限

自诞生以来，以GPT系列、Llama系列为代表的大型语言模型，凭借其强大的文本理解与生成能力，正在重塑人机交互的未来。然而，这些模型并非完美无瑕。其核心局限在于，模型的知识被静态地“编码”于其庞大的参数之中，这一过程在训练阶段完成。由此导致两大根本性问题：

  1. 知识时效性问题（Knowledge Cutoff）： 模型的知识停留在其最后一次训练的数据集所处的时间点。对于任何在此之后出现的新信息、新事件或数据更新，模型无法感知，从而在回答相关问题时表现出信息滞后甚至错误。

  2. 幻觉与可解释性问题（Hallucination & Interpretability）： 当面对其知识范围之外或模糊不清的查询时，LLM有时会生成看似合理但实际上与事实不符的“幻觉”内容。同时，由于其生成过程的“黑箱”特性，我们难以追溯其回答的信息来源，这在要求高准确性和可验证性的场景（如金融、法律、医疗）中是不可接受的。

为了克服这些局限，研究界与工业界探索出多种解决方案，其中，检索增强生成（RAG）被公认为当前最高效、最具扩展性的技术路径之一。

RAG的核心架构与技术组件

RAG的基本思想非常直接：在让LLM回答问题之前，先从一个外部的、可实时更新的知识库中检索出与问题最相关的信息，然后将这些信息作为上下文（Context）连同原始问题（Query）一起提供给LLM，引导其生成一个有据可依的、准确的答案。

一个标准的RAG系统主要由以下三大核心组件构成：

1. 索引（Indexing）
索引是构建RAG系统的第一步，其目标是将原始的非结构化或半结构化文档数据转化为机器可高效检索的格式。该过程包含：

  • 数据加载与切分（Loading & Chunking）： 从指定数据源（如文档库、数据库、API）加载原始数据。由于LLM处理的上下文长度有限，必须将长文档切分为更小的、逻辑上连贯的文本块（Chunks）。切分策略（如固定大小、按段落切分、递归切分）对最终的检索效果有重要影响。
  • 嵌入（Embedding）： 利用文本嵌入模型（如Sentence-Transformers, OpenAI Ada-002等）将每个文本块转换为高维向量（Vector Embedding）。这些向量能够捕捉文本的语义信息，使得语义上相近的文本块在向量空间中的距离也更近。

2. 检索（Retrieval）
检索是RAG系统的核心环节，负责根据用户的查询找到最相关的知识片段。

  • 查询向量化： 将用户的输入查询同样通过嵌入模型转换为查询向量。
  • 向量相似度搜索： 在索引好的向量数据库（Vector Database，如FAISS, Pinecone, Weaviate）中，计算查询向量与所有文本块向量之间的相似度（通常使用余弦相似度或点积）。
  • Top-K检索： 返回相似度得分最高的K个文本块，作为后续生成环节的候选上下文。

3. 生成（Generation）
生成是RAG系统的最终输出环节。

  • 上下文增强提示（Context-Augmented Prompting）： 将检索到的Top-K文本块与用户的原始查询整合到一个精心设计的Prompt模板中。一个典型的模板结构如下：
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    根据以下提供的上下文信息，请准确回答用户的问题。如果上下文中没有足够信息，请明确指出。

    [上下文]：
    {retrieved_chunk_1}
    {retrieved_chunk_2}
    ...

    [问题]：
    {user_query}

    [回答]：
  • LLM推理： 将构建好的增强提示送入LLM。LLM将基于其强大的语言能力，对提供的上下文进行理解、提炼和总结，最终生成一个忠实于上下文信息、逻辑清晰的答案。

前沿RAG优化策略

基础的RAG架构虽然有效，但在处理复杂查询和大规模知识库时仍面临挑战。学术界和工业界已发展出多种高级优化技术。

  • 混合搜索（Hybrid Search）： 将基于关键词的稀疏向量检索（如BM25）与基于语义的稠密向量检索相结合。这种方法能够同时利用关键词匹配的精确性和语义搜索的泛化能力，显著提升检索相关性，特别是在处理包含特定术语或实体名称的查询时。

  • 查询转换（Query Transformation）： 对用户的原始查询进行重写或扩展，以提升检索质量。例如，HyDE（Hypothetical Document Embeddings）技术会先让LLM针对原始问题生成一个假设性的答案文档，再将该假设性文档进行嵌入用于检索，实践证明这种方法能更有效地匹配到相关的真实文档。

  • 重排（Re-ranking）： 在初步检索（Retrieve）之后、送入生成器（Generate）之前增加一个重排环节。使用一个更轻量但更精准的模型（如Cross-Encoder）对初步检索返回的Top-K个文档进行重新打分和排序，筛选出与查询真正最相关的少数几个文档，以降低无关信息对LLM生成过程的干扰。

  • 分层与图RAG（Hierarchical & Graph RAG）： 针对大型复杂文档，可以构建文档的摘要或层级索引。检索时首先在高层级的摘要索引中定位相关文档，再在这些文档的原始文本块中进行精细检索。此外，利用知识图谱构建实体和关系索引的图RAG，能够支持更复杂的、需要多步推理的查询。

具体实现

在具体实现中，通常使用 LangChain 封装好的工具进行实现，具体的实现demo待我完成后发布在Github上

Posted on Edited on In ,

LLM 已在众多领域展现出惊人的能力。然而，当面对需要复杂、多步推理的自然语言任务时，即便是最前沿的模型也时常会遇到瓶颈。传统的解决方法，如让模型进行自我反思（Self-Reflection），有时会陷入“思想退化”（Degeneration-of-Thought）的困境，即模型因过度自信而无法修正自身的错误认知。

为了突破这一局限，研究者们开始探索多智能体协作的模式。然而，以往的“多智能体辩论”大多局限于同一模型的多个实例，这导致了固有的模型偏见、知识范围受限以及因预训练数据和架构相同而缺乏真正的外部反馈。

RECONCILE框架，通过组建一个由不同大型语言模型构成的“圆桌会议”，显著提升了AI的协同推理能力。

RECONCILE的核心机制：分组、讨论与说服

RECONCILE框架的设计灵感来源于人类社会中的集体决策过程，如头脑风暴和小组会议。它模拟了一个由多个不同LLM智能体（例如ChatGPT、Bard、Claude2）参与的圆桌会议，通过多轮结构化的讨论来达成更优的共识。其核心运作流程分为三个阶段：

  1. 第一阶段：初始响应生成 (Initial Response Generation)
    在讨论开始前，每一个独立的LLM智能体都会针对给定的推理问题，生成自己的初始答案、作为推理过程的解释（即“思维链”），以及一个量化的置信度分数。

  2. 第二阶段：多轮讨论 (Multi-Round Discussion)
    这是RECONCILE框架的精髓所在。在每一轮讨论中，系统会为每个智能体生成一个特制的“讨论提示”（discussion prompt）。该提示包含三大关键信息：

    • 分组后的各方观点：系统会汇总上一轮所有智能体的答案和解释，并按答案类别进行分组，清晰地呈现当前的观点分布 。
    • 各方置信度：每个观点旁边都附有提出该观点的智能体的置信度分数，为讨论提供决策权重参考。
    • “说服性样本” (Convincing Samples)：这是一个创新性的设计。提示中包含了一些人类提供的、能够有效纠正其他模型错误答案的解释范例。通过上下文学习（in-context learning），智能体可以借鉴这些样本，学习如何生成更有说服力的论据来修正或捍卫自己的立场。

    接收到讨论提示后，每个智能体会综合所有信息，生成更新后的答案、解释和置信度，进入下一轮讨论。

  3. 第三阶段：团队答案生成 (Team Answer Generation)
    讨论会持续进行，直到所有智能体达成共识，或达到预设的最大讨论轮数。最终，系统会采用一种基于置信度重校准的加权投票机制，来确定最终的团队答案。

多样性：RECONCILE成功的关键

该研究最核心的发现之一是，源于不同模型的多样性是框架性能卓越的关键。在一项消融实验中，仅“使用多种模型”这一项，就比“使用单一模型的多个实例”在StrategyQA数据集上带来了6.8%的性能提升。

研究人员通过BERTScore指标量化了不同模型响应之间的差异性，证实了来自不同LLM家族（如ChatGPT、Bard、Claude2）的解释比来自同一模型多个实例的解释具有更高的多样性（即更低的相似度）。这种多样性为系统带来了互补的知识和视角，有效打破了单一模型可能存在的“信息茧房”或“回音室效应”，从而通过外部反馈促进了更深层次的推理和修正。

显著的实验成果

RECONCILE框架在七个涵盖常识、数学、逻辑推理和自然语言推断的基准测试中，表现出了强大的性能。

  • 超越基线：相较于之前的单智能体（如Self-Refine）和多智能体（如Debate）方法，RECONCILE取得了最高11.4%的性能提升。
  • 媲美甚至超越GPT-4：在不包含GPT-4作为智能体的情况下，RECONCILE在StrategyQA和CSQA等三个数据集上的表现优于GPT-4。
  • 高度灵活性与通用性：该框架能够灵活地集成不同能力和类型的智能体，无论是更强的GPT-4、开源的LLaMA-2-70B，还是领域专用的DeepSeekMath模型。在整合了DeepSeekMath后，RECONCILE在极具挑战性的MATH数学基准上，性能比GPT-4和专业模型本身提升了8%。
  • 共同进步：值得注意的是，通过多轮讨论，不仅团队的整体表现得到提升，每个参与的智能体自身的准确率也得到了改善。

结论与展望

RECONCILE框架的提出，为提升大型语言模型的推理能力提供了一个极具前景的方向。它雄辩地证明，构建一个允许多样化AI智能体进行有效沟通、相互说服并达成共识的协作环境，其力量远超任何单一模型的闭门造车。这一研究将AI发展的焦点从单纯追求更大、更强的单一模型，部分转移到了如何设计高效的、具备集体智慧的AI系统上。未来，这种“AI圆桌会议”模式有望在科学研究、复杂决策支持和内容创作等领域发挥重要作用，推动人工智能向更深层次的认知和推理能力迈进。

0%