文章目录
- RRHF
- PRO
- 将RLHF嫁接到PRO
 
- 参考资料
 
RRHF
RRHF(Rank Responses to align Human Feedback)出自2023年4月的论文《RRHF: Rank Responses to Align Language Models with Human Feedback without tears》,是较早提出的不需要使用PPO来对齐人类偏好的方法。
设输入数据记为x,输出记为y,奖励函数为R(x,y),待训练模型记为 π \pi π(从模型 ρ \rho ρ初始化得到)。
在训练前,先对输入从不同来源采样输出(response)构建数据集,来源包括待训练模型、ChatGPT、GPT-4、人工标注的高质量和低质量输出。训练时,对于一个输入x,就有k个不同的输出 
     
      
       
        
        
          y 
         
        
          i 
         
        
       
      
        y_i 
       
      
    yi( 
     
      
       
       
         1 
        
       
         ≤ 
        
       
         i 
        
       
         ≤ 
        
       
         k 
        
       
      
        1 \le i \le k 
       
      
    1≤i≤k),奖励函数给每一个 
     
      
       
        
        
          y 
         
        
          i 
         
        
       
      
        y_i 
       
      
    yi的打分为 
     
      
       
       
         R 
        
       
         ( 
        
       
         x 
        
       
         , 
        
        
        
          y 
         
        
          i 
         
        
       
         ) 
        
       
         = 
        
        
        
          r 
         
        
          i 
         
        
       
      
        R(x, y_i) = r_i 
       
      
    R(x,yi)=ri,为了使模型与分数 
     
      
       
       
         { 
        
        
        
          r 
         
        
          i 
         
        
        
        
          } 
         
        
          k 
         
        
       
      
        \{ r_i\}_k 
       
      
    {ri}k对齐,让模型 
     
      
       
       
         π 
        
       
      
        \pi 
       
      
    π对每一个 
     
      
       
        
        
          y 
         
        
          i 
         
        
       
      
        y_i 
       
      
    yi使用下式计算分数 
     
      
       
        
        
          p 
         
        
          i 
         
        
       
      
        p_i 
       
      
    pi:
  
      
       
        
         
         
           p 
          
         
           i 
          
         
        
          = 
         
        
          − 
         
         
          
           
           
             ∑ 
            
           
             t 
            
           
          
            log 
           
          
             
           
           
           
             P 
            
           
             π 
            
           
           
           
             ( 
            
            
            
              y 
             
             
             
               i 
              
             
               , 
              
             
               t 
              
             
            
           
             ∣ 
            
           
             x 
            
           
             , 
            
            
            
              y 
             
             
             
               i 
              
             
               , 
              
             
               < 
              
             
               t 
              
             
            
           
             ) 
            
           
          
          
          
            ∣ 
           
          
            ∣ 
           
           
           
             y 
            
           
             i 
            
           
          
            ∣ 
           
          
            ∣ 
           
          
         
         
        
          ( 
         
        
          1.1 
         
        
          ) 
         
        
       
         p_{i}=-\frac{\sum_{t} \log P_{\mathcal{\pi}}\left(y_{i, t} \mid x, y_{i,<t}\right)}{||y_i||} \qquad (1.1) 
        
       
     pi=−∣∣yi∣∣∑tlogPπ(yi,t∣x,yi,<t)(1.1)
  
     
      
       
        
        
          p 
         
        
          i 
         
        
       
      
        p_i 
       
      
    pi是模型 
     
      
       
       
         π 
        
       
      
        \pi 
       
      
    π 下 
     
      
       
        
        
          y 
         
        
          i 
         
        
       
      
        y_i 
       
      
    yi的对数条件概率,目的是使模型 
     
      
       
       
         π 
        
       
      
        \pi 
       
      
    π对高质量输出给更大概率,对低质量输出给小概率。使用如下ranking loss来优化这个目标:
  
      
       
        
         
         
           L 
          
          
          
            r 
           
          
            a 
           
          
            n 
           
          
            k 
           
          
         
        
          = 
         
         
         
           ∑ 
          
          
           
           
             r 
            
           
             i 
            
           
          
            < 
           
           
           
             r 
            
           
             j 
            
           
          
         
        
          m 
         
        
          a 
         
        
          x 
         
        
          ( 
         
        
          0 
         
        
          , 
         
         
         
           p 
          
         
           i 
          
         
        
          − 
         
         
         
           p 
          
         
           j 
          
         
        
          ) 
         
         
        
          ( 
         
        
          1.2 
         
        
          ) 
         
        
       
         L_{rank} = \sum_{r_i < r_j} max(0, p_i - p_j) \qquad (1.2) 
        
       
     Lrank=ri<rj∑max(0,pi−pj)(1.2)
 此外要求模型从最高奖励的输出学习,损失与SFT的交叉熵损失类似:
  
      
       
        
         
         
           i 
          
         
           ′ 
          
         
        
          = 
         
         
          
          
            a 
           
          
            r 
           
          
            g 
           
          
            m 
           
          
            a 
           
          
            x 
           
          
         
           i 
          
         
        
            
         
         
         
           r 
          
         
           i 
          
         
         
         
         
           L 
          
          
          
            f 
           
          
            t 
           
          
         
        
          = 
         
        
          − 
         
         
         
           ∑ 
          
         
           t 
          
         
        
          log 
         
        
           
         
         
         
           P 
          
         
           π 
          
         
         
         
           ( 
          
          
          
            y 
           
           
            
            
              i 
             
            
              ′ 
             
            
           
             , 
            
           
             t 
            
           
          
         
           ∣ 
          
         
           x 
          
         
           , 
          
          
          
            y 
           
           
            
            
              i 
             
            
              ′ 
             
            
           
             , 
            
           
             < 
            
           
             t 
            
           
          
         
           ) 
          
         
         
        
          ( 
         
        
          1.3 
         
        
          ) 
         
        
       
         i^{\prime} = \mathop{arg max}_i\ { r_i} \\ L_{ft} = - \sum_t \log P_{\mathcal{\pi}}\left(y_{i^{\prime}, t} \mid x, y_{i^{\prime},<t}\right) \qquad (1.3) 
        
       
     i′=argmaxi riLft=−t∑logPπ(yi′,t∣x,yi′,<t)(1.3)
 RRHF的最终目标为这两部分损失之和:
  
      
       
        
        
          L 
         
        
          = 
         
         
         
           L 
          
          
          
            r 
           
          
            a 
           
          
            n 
           
          
            k 
           
          
         
        
          + 
         
         
         
           L 
          
          
          
            f 
           
          
            t 
           
          
         
         
        
          ( 
         
        
          1.4 
         
        
          ) 
         
        
       
         L = L_{rank} + L_{ft} \qquad (1.4) 
        
       
     L=Lrank+Lft(1.4)
PRO
PRO(Preference Ranking Optimization)出自2023年6月的论文《Preference Ranking Optimization for Human Alignment》, 与RRHF一样,也是基于排序的对齐方法。相比于RRHF只使用两个输出进行pair-wise排序,PRO会考虑多个输出之间的排序。

设输入prompt为x,两个输出为 
     
      
       
        
        
          y 
         
        
          1 
         
        
       
      
        y^1 
       
      
    y1和 
     
      
       
        
        
          y 
         
        
          2 
         
        
       
      
        y^2 
       
      
    y2,人工标注的偏好为 
     
      
       
        
        
          y 
         
        
          1 
         
        
       
         ≻ 
        
        
        
          y 
         
        
          2 
         
        
       
           
        
       
         ∣ 
        
       
           
        
       
         x 
        
       
      
        y^1 \succ y^2\ |\ x 
       
      
    y1≻y2 ∣ x,Bradley-Terry(BT)模型定义的偏好概率如下式,其目标可以看作为二分类问题奖励模型: 
     
      
       
        
        
          L 
         
         
         
           B 
          
         
           T 
          
         
        
       
         = 
        
       
         − 
        
       
         log 
        
       
          
        
       
         σ 
        
       
         ( 
        
        
        
          r 
         
        
          ϕ 
         
        
       
         ( 
        
       
         x 
        
       
         , 
        
        
        
          y 
         
        
          1 
         
        
       
         ) 
        
       
         − 
        
        
        
          r 
         
        
          ϕ 
         
        
       
         ( 
        
       
         x 
        
       
         , 
        
        
        
          y 
         
        
          2 
         
        
       
         ) 
        
       
         ) 
        
       
      
        \mathcal{L}_{BT} = -\log \sigma(r_{\phi}(x, y^1) - r_{\phi}(x, y^2)) 
       
      
    LBT=−logσ(rϕ(x,y1)−rϕ(x,y2)), 
     
      
       
        
        
          r 
         
        
          ϕ 
         
        
       
      
        r_{\phi} 
       
      
    rϕ是奖励模型。
  
      
       
        
         
         
           P 
          
          
          
            P 
           
          
            B 
           
          
         
        
          = 
         
         
          
          
            exp 
           
          
             
           
          
            ( 
           
           
           
             r 
            
           
             ϕ 
            
           
          
            ( 
           
          
            x 
           
          
            , 
           
           
           
             y 
            
           
             1 
            
           
          
            ) 
           
          
            ) 
           
          
          
          
            exp 
           
          
             
           
          
            ( 
           
           
           
             r 
            
           
             ϕ 
            
           
          
            ( 
           
          
            x 
           
          
            , 
           
           
           
             y 
            
           
             1 
            
           
          
            ) 
           
          
            ) 
           
          
            + 
           
          
            exp 
           
          
             
           
          
            ( 
           
           
           
             r 
            
           
             ϕ 
            
           
          
            ( 
           
          
            x 
           
          
            , 
           
           
           
             y 
            
           
             2 
            
           
          
            ) 
           
          
            ) 
           
          
         
         
        
          ( 
         
        
          2.1 
         
        
          ) 
         
        
       
         P_{PB} = \frac{\exp(r_{\phi}(x, y^1))} {\exp(r_{\phi}(x, y^1)) + \exp(r_{\phi}(x, y^2))} \qquad (2.1) 
        
       
     PPB=exp(rϕ(x,y1))+exp(rϕ(x,y2))exp(rϕ(x,y1))(2.1)
如果输入prompt x对应n个可能的输出 
     
      
       
       
         { 
        
        
        
          y 
         
        
          i 
         
        
       
         } 
        
       
      
        \{ y^i\} 
       
      
    {yi},且有偏好标注顺序 
     
      
       
        
        
          y 
         
        
          1 
         
        
       
         ≻ 
        
        
        
          y 
         
        
          2 
         
        
       
         ≻ 
        
       
         ⋯ 
        
       
         ≻ 
        
        
        
          y 
         
        
          n 
         
        
       
      
        y^1 \succ y^2 \succ \cdots \succ y^n 
       
      
    y1≻y2≻⋯≻yn,则可以定义 
     
      
       
        
        
          y 
         
        
          1 
         
        
       
      
        y^1 
       
      
    y1和偏好排序在其之后的输出满足 
     
      
       
        
        
          y 
         
         
         
           1 
          
         
           , 
          
         
           2 
          
         
           : 
          
         
           n 
          
         
        
       
         = 
        
        
        
          y 
         
        
          1 
         
        
       
         ≻ 
        
        
         
         
           y 
          
         
           2 
          
         
        
          , 
         
        
          ⋯ 
          
        
          , 
         
         
         
           y 
          
         
           n 
          
         
        
       
      
        y^{1,2:n}=y^1 \succ {y^2, \cdots, y^n} 
       
      
    y1,2:n=y1≻y2,⋯,yn,那么Bradley-Terry(BT)的目标将变成下式:
  
      
       
        
        
          P 
         
        
          ( 
         
         
         
           y 
          
          
          
            1 
           
          
            , 
           
          
            2 
           
          
            : 
           
          
            n 
           
          
         
        
          ∣ 
         
        
          x 
         
        
          ) 
         
        
          = 
         
         
          
          
            exp 
           
          
             
           
          
            ( 
           
          
            r 
           
          
            ( 
           
          
            x 
           
          
            , 
           
           
           
             y 
            
           
             1 
            
           
          
            ) 
           
          
            ) 
           
          
          
           
           
             ∑ 
            
            
            
              i 
             
            
              = 
             
            
              1 
             
            
           
             n 
            
           
          
            exp 
           
          
             
           
          
            ( 
           
          
            r 
           
          
            ( 
           
          
            x 
           
          
            , 
           
           
           
             y 
            
           
             i 
            
           
          
            ) 
           
          
            ) 
           
          
         
         
        
          ( 
         
        
          2.2 
         
        
          ) 
         
        
       
         P(y^{1, 2:n}|x) = \frac {\exp(r(x, y^1))}{ \sum^n_{i=1}\exp (r(x, y^i))} \qquad (2.2) 
        
       
     P(y1,2:n∣x)=∑i=1nexp(r(x,yi))exp(r(x,y1))(2.2)
 我们可以很容易想到上述目标没有完全利用排序信息,只使用了 
     
      
       
        
        
          y 
         
        
          1 
         
        
       
         ≻ 
        
        
         
         
           y 
          
         
           2 
          
         
        
          , 
         
        
          ⋯ 
          
        
          , 
         
         
         
           y 
          
         
           n 
          
         
        
       
      
        y^1 \succ {y^2, \cdots, y^n} 
       
      
    y1≻y2,⋯,yn,而剩余的n-2个排序如 
     
      
       
        
        
          y 
         
        
          2 
         
        
       
         ≻ 
        
        
         
         
           y 
          
         
           3 
          
         
        
          , 
         
        
          ⋯ 
          
        
          , 
         
         
         
           y 
          
         
           n 
          
         
        
       
      
        y^2 \succ {y^3, \cdots, y^n} 
       
      
    y2≻y3,⋯,yn、 
     
      
       
        
        
          y 
         
         
         
           n 
          
         
           − 
          
         
           1 
          
         
        
       
         ≻ 
        
        
        
          y 
         
        
          n 
         
        
       
      
        y^{n-1} \succ y^n 
       
      
    yn−1≻yn则没有被使用,所以PRO的作者将上式扩展为下式:
  
      
       
        
         
          
           
            
            
              P 
             
            
              ( 
             
             
             
               y 
              
              
              
                1 
               
              
                , 
               
              
                ⋯ 
                
              
                , 
               
              
                n 
               
              
             
            
              ∣ 
             
            
              x 
             
            
              ) 
             
            
           
          
          
           
            
             
            
              = 
             
             
             
               ∏ 
              
              
              
                k 
               
              
                = 
               
              
                1 
               
              
              
              
                n 
               
              
                − 
               
              
                1 
               
              
             
            
              P 
             
            
              ( 
             
             
             
               y 
              
              
              
                k 
               
              
                , 
               
              
                k 
               
              
                + 
               
              
                1 
               
              
                : 
               
              
                n 
               
              
             
            
              ∣ 
             
            
              x 
             
            
              ) 
             
            
           
          
         
         
          
           
            
           
          
          
           
            
             
            
              = 
             
             
             
               ∏ 
              
              
              
                k 
               
              
                = 
               
              
                1 
               
              
              
              
                n 
               
              
                − 
               
              
                1 
               
              
             
             
              
              
                exp 
               
              
                 
               
              
                ( 
               
              
                r 
               
              
                ( 
               
              
                x 
               
              
                , 
               
               
               
                 y 
                
               
                 k 
                
               
              
                ) 
               
              
                ) 
               
              
              
               
               
                 ∑ 
                
                
                
                  i 
                 
                
                  = 
                 
                
                  k 
                 
                
               
                 n 
                
               
              
                exp 
               
              
                 
               
              
                ( 
               
              
                r 
               
              
                ( 
               
              
                x 
               
              
                , 
               
               
               
                 y 
                
               
                 i 
                
               
              
                ) 
               
              
                ) 
               
              
             
             
            
              ( 
             
            
              2.3 
             
            
              ) 
             
            
           
          
         
        
       
         \begin{aligned} P(y^{1, \cdots ,n}|x) &= \prod_{k=1}^{n-1}P(y^{k,k+1:n}|x) \\ &= \prod_{k=1}^{n-1} \frac {\exp(r(x, y^k))}{ \sum^n_{i=k}\exp (r(x, y^i))} \qquad (2.3) \end{aligned} 
        
       
     P(y1,⋯,n∣x)=k=1∏n−1P(yk,k+1:n∣x)=k=1∏n−1∑i=knexp(r(x,yi))exp(r(x,yk))(2.3)
 PRO定义 
     
      
       
        
        
          r 
         
         
         
           π 
          
         
           PRO 
          
         
        
       
         ( 
        
       
         x 
        
       
         , 
        
        
        
          y 
         
        
          k 
         
        
       
         ) 
        
       
      
        r_{\pi_{\text{PRO}}}(x, y^k) 
       
      
    rπPRO(x,yk)为以目标LLM  
     
      
       
        
        
          π 
         
        
          PRO 
         
        
       
      
        \pi_{\text{PRO}} 
       
      
    πPRO为参数的函数,即LLM  
     
      
       
        
        
          π 
         
        
          PRO 
         
        
       
      
        \pi_{\text{PRO}} 
       
      
    πPRO通过将 
     
      
       
        
        
          π 
         
        
          PRO 
         
        
       
      
        \pi_{\text{PRO}} 
       
      
    πPRO生成的每个token的概率相乘来计算输出 
     
      
       
        
        
          y 
         
        
          k 
         
        
       
      
        y^k 
       
      
    yk的分数。
  
      
       
        
         
         
           r 
          
          
          
            π 
           
          
            PRO 
           
          
         
        
          ( 
         
        
          x 
         
        
          , 
         
         
         
           y 
          
         
           k 
          
         
        
          ) 
         
        
          = 
         
         
         
           1 
          
          
          
            ∣ 
           
           
           
             y 
            
           
             k 
            
           
          
            ∣ 
           
          
         
         
         
           ∑ 
          
          
          
            t 
           
          
            = 
           
          
            1 
           
          
          
          
            ∣ 
           
           
           
             y 
            
           
             k 
            
           
          
            ∣ 
           
          
         
        
          log 
         
        
           
         
         
         
           P 
          
          
          
            π 
           
          
            PRO 
           
          
         
        
          ( 
         
         
         
           y 
          
         
           t 
          
         
           k 
          
         
        
          ∣ 
         
        
          x 
         
        
          , 
         
         
         
           y 
          
          
          
            < 
           
          
            k 
           
          
         
           k 
          
         
        
          ) 
         
         
        
          ( 
         
        
          2.4 
         
        
          ) 
         
        
       
         r_{\pi_{\text{PRO}}}(x, y^k) = \frac{1}{|y^k|} \sum^{|y^k|}_{t=1} \log P_{\pi_{\text{PRO}}} (y^k_t | x, y^k_{<k}) \qquad (2.4) 
        
       
     rπPRO(x,yk)=∣yk∣1t=1∑∣yk∣logPπPRO(ytk∣x,y<kk)(2.4)
 PRO的优化目标如下式:
  
      
       
        
        
          L 
         
        
          ( 
         
         
         
           y 
          
          
          
            1 
           
          
            , 
           
          
            ⋯ 
            
          
            , 
           
          
            n 
           
          
         
        
          ∣ 
         
        
          x 
         
        
          ) 
         
        
          = 
         
         
         
           L 
          
         
           PRO 
          
         
        
          + 
         
        
          β 
         
         
         
           L 
          
         
           SFT 
          
         
         
        
          ( 
         
        
          2.5 
         
        
          ) 
         
        
       
         \mathcal{L}(y^{1,\cdots, n}|x) = \mathcal{L}_{\text{PRO}} + \beta \mathcal{L}_{\text{SFT}} \qquad (2.5) 
        
       
     L(y1,⋯,n∣x)=LPRO+βLSFT(2.5)
  
     
      
       
        
        
          L 
         
        
          SFT 
         
        
       
      
        \mathcal{L}_{\text{SFT}} 
       
      
    LSFT是使用top 1候选输出得到的NLL损失, 
     
      
       
       
         β 
        
       
      
        \beta 
       
      
    β是用来平衡文本质量和人类偏好的超参, 
     
      
       
        
        
          L 
         
        
          PRO 
         
        
       
      
        \mathcal{L}_{\text{PRO}} 
       
      
    LPRO的定义如下(即前面2.3式的对数形式):
  
      
       
        
         
         
           L 
          
         
           PRO 
          
         
        
          = 
         
         
         
           ∑ 
          
          
          
            k 
           
          
            = 
           
          
            1 
           
          
          
          
            n 
           
          
            − 
           
          
            1 
           
          
         
        
          log 
         
        
           
         
         
          
          
            exp 
           
          
             
           
          
            ( 
           
           
           
             r 
            
            
            
              π 
             
            
              PRO 
             
            
           
          
            ( 
           
          
            x 
           
          
            , 
           
           
           
             y 
            
           
             k 
            
           
          
            ) 
           
          
            ) 
           
          
          
           
           
             ∑ 
            
            
            
              i 
             
            
              = 
             
            
              k 
             
            
           
             n 
            
           
          
            exp 
           
          
             
           
          
            ( 
           
           
           
             r 
            
            
            
              π 
             
            
              PRO 
             
            
           
          
            ( 
           
          
            x 
           
          
            , 
           
           
           
             y 
            
           
             i 
            
           
          
            ) 
           
          
            ) 
           
          
         
         
        
          ( 
         
        
          2.6 
         
        
          ) 
         
        
       
         \mathcal{L}_{\text{PRO}} = \sum_{k=1}^{n-1} \log \frac {\exp(r_{\pi_{\text{PRO}}}(x, y^k))}{ \sum^n_{i=k}\exp (r_{\pi_{\text{PRO}}}(x, y^i))} \qquad (2.6) 
        
       
     LPRO=k=1∑n−1log∑i=knexp(rπPRO(x,yi))exp(rπPRO(x,yk))(2.6)
将RLHF嫁接到PRO
PRO不需要奖励模型就可以直接在人类标注偏好排序序列上进行优化,但作者也进行了试验发现将RLHF嫁接到PRO给其带来更多的灵活性,所以作者提出了如下三种可能的结合方式:
-  Affordable Preference Ranking。PRO只依赖于人类偏好排序序列,但其数据来源没有被限定,即可以通过人工方式生成不同质量的多个输出,也可以利用已有LLM如ChatGPT、Alpaca等来生成不同的输出。生成的输出再由一个奖励模型 r ϕ r_{\phi} rϕ来排序。 
-  Differentiated Contrast。前面2.6式 L PRO \mathcal{L}_{\text{PRO}} LPRO的定义将全部满足 y i ≺ y k y^i \prec y^k yi≺yk的输出作为 y k y^k yk的负样本并施加相同的惩罚。这种处理方式可能不合理,比如 y k + 1 y^{k+1} yk+1只比 y k y^k yk的效果差一点点,而 y n y^n yn比 y k y^k yk效果差很多,与 y k y^k yk比较时模型应该轻微地惩罚 y k + 1 y^{k+1} yk+1而重重地惩罚 y n y^n yn。于是PRO作者将式2.6修改为下式,由奖励模型 r ϕ r_{\phi} rϕ得到的分数 r ϕ ( x , y i ) r_{\phi}(x, y^i) rϕ(x,yi)表明 y i y^i yi的数值偏好。 
 L PRO = ∑ k = 1 n − 1 log  exp  ( r π PRO ( x , y k ) T k k ) ∑ i = k n exp  ( r π PRO ( x , y i ) T k i ) ( 2.7 ) \mathcal{L}_{\text{PRO}} = \sum_{k=1}^{n-1} \log \frac {\exp \left( \frac{r_{\pi_{\text{PRO}}}(x, y^k)}{\mathcal{T}^k_k} \right)} { \sum^n_{i=k}\exp \left( \frac{r_{\pi_{\text{PRO}}}(x, y^i)}{\mathcal{T}^i_k} \right)} \qquad (2.7) LPRO=k=1∑n−1log∑i=knexp(TkirπPRO(x,yi))exp(TkkrπPRO(x,yk))(2.7)
 上式中
 T k i > k = 1 r ϕ ( x , y k ) − r ϕ ( x , y i ) T k k = min  i > k T k i \mathcal{T}^{i>k}_k = \frac {1}{r_{\phi}(x, y^k) - r_{\phi}(x, y^i)} \\ \mathcal{T}^{k}_k = \min_{i>k} \mathcal{T}^{i}_k Tki>k=rϕ(x,yk)−rϕ(x,yi)1Tkk=i>kminTki
 也就是将原有的 L PRO \mathcal{L}_{\text{PRO}} LPRO添加了动态温度参数,如果 r ϕ ( x , y k ) r_{\phi}(x, y^k) rϕ(x,yk) 和 r ϕ ( x , y i ) r_{\phi}(x, y^i) rϕ(x,yi)之间的差值增加, y k y^k yk和 y i y^i yi之间的偏好差距更明显,温度 T k i \mathcal{T}^i_k Tki减小放大了正例 y k y^k yk相比于 y i y_i yi的惩罚。 T k k \mathcal{T}^k_k Tkk定义为所有负例里的最小温度值有助于维持分子和分母的平衡。
-  Self-bootstrapping Augmentation。PRO对于偏好序列的长度要求不是固定的,所以可以将RLHF里的自举(self-bootstrapping)优势应用到PRO,即给定prompt x和当前模型,采样输出 y ^ \hat{y} y^将其添加到输出集 { y 1 , ⋯ , y n } \{y^1, \cdots, y^n \} {y1,⋯,yn},并使用奖励模型重新排序输出集得到 p ( y ^ 1 , ⋯ , n + 1 ∣ x ) p(\hat{y}^{1, \cdots, n+1} | x) p(y^1,⋯,n+1∣x), L PRO \mathcal{L}_{\text{PRO}} LPRO相应地变成: 
 L PRO ( y 1 , ⋯ , n ∣ x ) ⇒ L PRO ( y ^ 1 , ⋯ , n + 1 ∣ x ) \mathcal{L}_{\text{PRO}}(y^{1, \cdots, n}|x) \Rightarrow \mathcal{L}_{\text{PRO}}(\hat{y}^{1, \cdots, n+1} | x) LPRO(y1,⋯,n∣x)⇒LPRO(y^1,⋯,n+1∣x)
 其训练过程如下图
  
参考资料
- RRHF:arxiv, github
- PRO:arxiv, github


















