Paano Namin Sinesanay ang Shannon V1.5 na Mag-isip Gamit ang GRPO

1. Motibasyon: Bakit Mga Modelo ng Pag-iisip?

Para saAI red teampananaliksik, ang pag-unawakung paanonakakarating ang isang AI sa mga potensyal na mapaminsalang output ay kasinghalaga ng pag-aaral sa mga output mismo. Ang mga modelo ng pag-iisip ng Shannon V1.5 ay naglalantad ng buong chain-of-thought, na nagbibigay-daan sa mga mananaliksik na:

• Subaybayan ang landas ng pagdadahilan na humahantong sauncensored na AI na kasunod namga pag-uugali
• Tukuyin kung saan karaniwang mamamagitan ang mga guardrail (nagpapakita ngkahalagahan ng guardrail ng AI)
• Bumuo ng mas matatag na mekanismo ng kaligtasan na nagta-target ng mga partikular na pattern ng pagdadahilan
• Gumawa ng mas mahusay na adversarial test cases batay sa mga naobserbahang chain ng pagdadahilan

2. Pag-unawa sa GRPO

Group Relative Policy Optimization (GRPO)ay isang pag-unlad sa tradisyonal na pamamaraan ng RLHF na nagbibigay-daan sa mas matatag at mahusay na pagsasanay ng mga kakayahan sa pagdadahilan. Binuo ng DeepSeek AI, napatunayan itong partikular na epektibo para sa pagsasanay ng chain-of-thought.

Bakit GRPO Higit sa Tradisyonal na RLHF?

Pundasyong Matematikal ng GRPO

Ino-optimize ng GRPO ang patakaran sa pamamagitan ng paghahambing ng mga tugon sa loob ng mga grupo sa halip na laban sa isang absolute reward model:

Ang relatibong paghahambing na ito ay may ilang mga bentahe:

• Normalisasyon:Awtomatikong nag-a-adjust para sa iba't ibang kahirapan sa mga prompt
• Katatagan:Binabawasan ang variance sa mga pagtatantya ng gradient
• Kahusayan:Walang hiwalay na reward model na kailangan

def compute_grpo_loss(
    policy_logprobs: torch.Tensor,
    rewards: torch.Tensor,
    group_size: int = 8
) -> torch.Tensor:
    """
    Compute GRPO loss with group-relative reward normalization.
    
    Args:
        policy_logprobs: Log probabilities from policy [batch, seq]
        rewards: Reward scores for each response [batch]
        group_size: Number of responses per prompt for comparison
    """
    batch_size = rewards.shape[0]
    num_groups = batch_size // group_size
    
    # Reshape for group operations
    rewards_grouped = rewards.view(num_groups, group_size)
    logprobs_grouped = policy_logprobs.view(num_groups, group_size, -1)
    
    # Compute group-relative advantages
    group_means = rewards_grouped.mean(dim=1, keepdim=True)
    group_stds = rewards_grouped.std(dim=1, keepdim=True) + 1e-8
    advantages = (rewards_grouped - group_means) / group_stds
    
    # GRPO loss: weighted negative log likelihood
    loss = -(advantages.unsqueeze(-1) * logprobs_grouped).sum(dim=-1).mean()
    
    return loss

3. DeepSeek Distilasyon

Upang simulan ang mga kakayahan sa pag-iisip ng Shannon V1.5, dinistill namin ang mga pattern ng chain-of-thought mula sa mga modelo ng pagdadahilan ng DeepSeek. Nagbigay ito ng mataas na kalidad na mga bakas ng CoT upang sanayin ang aming thinking head.

Komposisyon ng Dataset ng DeepSeek

Proseso ng Pagkolekta ng Bakas

Nangolekta kami ng mga bakas ng pag-iisip sa iba't ibang domain upang matiyak ang komprehensibong saklaw ng pangangatwiran:

class DeepSeekDistiller:
    """Distill chain-of-thought traces from DeepSeek models."""
    
    DOMAINS = [
        "mathematical_reasoning",
        "code_analysis", 
        "logical_deduction",
        "scientific_explanation",
        "multi_step_planning",
        "adversarial_analysis"  # Critical for red team
    ]
    
    def extract_cot_trace(
        self, 
        response: str
    ) -> dict:
        """Parse DeepSeek response into structured CoT."""
        
        # DeepSeek uses ... tags
        think_match = re.search(
            r'(.*?)', 
            response, 
            re.DOTALL
        )
        
        if not think_match:
            return None
            
        thinking = think_match.group(1)
        final_answer = response.split('')[-1].strip()
        
        # Parse individual reasoning steps
        steps = self.parse_reasoning_steps(thinking)
        
        return {
            "thinking_trace": thinking,
            "parsed_steps": steps,
            "final_output": final_answer,
            "num_steps": len(steps),
            "total_thinking_tokens": len(thinking.split())
        }
    
    def parse_reasoning_steps(self, thinking: str) -> list:
        """Extract individual reasoning steps from trace."""
        # Split on common step indicators
        step_patterns = [
            r'\n\d+\.',           # "1. ", "2. "
            r'\nStep \d+:',       # "Step 1:"
            r'\n(?:First|Next|Then|Finally),',
            r'\n- '              # Bullet points
        ]
        
        combined_pattern = '|'.join(step_patterns)
        steps = re.split(combined_pattern, thinking)
        
        return [s.strip() for s in steps if s.strip()]

4. Arkitektura ng Ulo ng Pag-iisip

Ang mga modelo ng Shannon V1.5 ay nagsasama ng isang nakalaangulo ng pag-iisipna bumubuo ng tahasang mga bakas ng pangangatwiran bago ang huling output. Ang karagdagang arkitektural na ito ay nagbibigay-daan sa transparent na CoT nang hindi binabago ang batayang arkitektura ng Mixtral.

Implementasyon ng Ulo ng Pag-iisip

class ThinkingHead(nn.Module):
    """
    Dedicated thinking module for Shannon V1.5.
    Generates explicit chain-of-thought traces.
    """
    
    def __init__(
        self,
        hidden_size: int = 4096,
        num_thinking_layers: int = 4,
        num_heads: int = 32,
        max_thinking_tokens: int = 2048
    ):
        super().__init__()
        
        self.hidden_size = hidden_size
        self.max_thinking_tokens = max_thinking_tokens
        
        # Special tokens
        self.think_start = nn.Parameter(torch.randn(1, 1, hidden_size))
        self.think_end = nn.Parameter(torch.randn(1, 1, hidden_size))
        
        # Thinking transformer layers
        self.thinking_layers = nn.ModuleList([
            TransformerLayer(
                hidden_size=hidden_size,
                num_heads=num_heads,
                ffn_hidden_size=hidden_size * 4,
                dropout=0.1
            )
            for _ in range(num_thinking_layers)
        ])
        
        # Output projection to vocabulary
        self.output_proj = nn.Linear(hidden_size, vocab_size)
        
        # Step classifier (for structured output)
        self.step_classifier = nn.Linear(hidden_size, 5)  # 5 step types
    
    def forward(
        self,
        hidden_states: torch.Tensor,
        attention_mask: torch.Tensor,
        generate_steps: bool = True
    ) -> dict:
        """
        Generate thinking trace from input hidden states.
        
        Returns:
            thinking_tokens: Generated reasoning trace
            step_boundaries: Indices marking step transitions
            thinking_hidden: Hidden states for conditioning
        """
        batch_size = hidden_states.shape[0]
        
        # Prepend thinking start token
        thinking_input = torch.cat([
            self.think_start.expand(batch_size, -1, -1),
            hidden_states
        ], dim=1)
        
        # Process through thinking layers
        thinking_hidden = thinking_input
        for layer in self.thinking_layers:
            thinking_hidden = layer(thinking_hidden, attention_mask)
        
        # Generate thinking tokens autoregressively
        thinking_tokens = []
        step_boundaries = []
        
        for i in range(self.max_thinking_tokens):
            logits = self.output_proj(thinking_hidden[:, -1, :])
            next_token = logits.argmax(dim=-1)
            
            # Check for step boundaries
            step_type = self.step_classifier(thinking_hidden[:, -1, :])
            if step_type.argmax(dim=-1) != 0:  # 0 = continue
                step_boundaries.append(i)
            
            thinking_tokens.append(next_token)
            
            # Check for think_end
            if next_token == self.think_end_token_id:
                break
            
            # Update for next iteration
            # ... (autoregressive generation logic)
        
        return {
            "thinking_tokens": torch.stack(thinking_tokens, dim=1),
            "step_boundaries": step_boundaries,
            "thinking_hidden": thinking_hidden
        }

5. Pipeline ng Pagsasanay

Yugto 1: Pre-training ng Ulo ng Pag-iisip

Una, sinasanay namin ang ulo ng pag-iisip sa mga bakas ng CoT na distilled ng DeepSeek gamit ang karaniwang cross-entropy loss:

# Thinking Head Pre-training Configuration
model:
  base: shannon-ai/v1-deep  # Start from GPT-5 distilled model
  thinking_head:
    num_layers: 4
    hidden_size: 4096
    max_tokens: 2048

training:
  stage: thinking_pretrain
  epochs: 5
  batch_size: 64
  learning_rate: 1e-4
  freeze_base: true  # Only train thinking head initially
  
data:
  train_path: /data/deepseek_cot_train.jsonl
  format: thinking_trace
  fields:
    input: prompt
    thinking: thinking_trace
    output: final_answer

Yugto 2: GRPO Fine-tuning

Pagkatapos ng pre-training, inilalapat namin ang GRPO upang mapabuti ang kalidad ng pag-iisip gamit ang mga paghahambing na group-relative:

class GRPOTrainer:
    """GRPO trainer for thinking model optimization."""
    
    def __init__(
        self,
        model: ThinkingModel,
        group_size: int = 8,
        kl_coef: float = 0.1
    ):
        self.model = model
        self.group_size = group_size
        self.kl_coef = kl_coef
        self.ref_model = copy.deepcopy(model)
        self.ref_model.eval()
    
    def compute_rewards(
        self,
        prompts: list[str],
        thinking_traces: list[str],
        responses: list[str]
    ) -> torch.Tensor:
        """
        Compute rewards for thinking quality.
        Multiple signals combined for comprehensive evaluation.
        """
        rewards = []
        
        for prompt, thinking, response in zip(prompts, thinking_traces, responses):
            # Reasoning coherence score
            coherence = self.evaluate_coherence(thinking)
            
            # Step structure quality
            structure = self.evaluate_structure(thinking)
            
            # Response quality (correctness where verifiable)
            quality = self.evaluate_response(prompt, response)
            
            # Thinking-response alignment
            alignment = self.evaluate_alignment(thinking, response)
            
            # Combined reward
            reward = (
                0.3 * coherence +
                0.2 * structure +
                0.3 * quality +
                0.2 * alignment
            )
            rewards.append(reward)
        
        return torch.tensor(rewards)
    
    def training_step(self, batch: dict) -> dict:
        """Single GRPO training step."""
        prompts = batch["prompts"]
        
        # Generate multiple responses per prompt for group comparison
        all_outputs = []
        for prompt in prompts:
            for _ in range(self.group_size):
                output = self.model.generate_with_thinking(
                    prompt,
                    temperature=0.8,  # Diversity for comparison
                    do_sample=True
                )
                all_outputs.append(output)
        
        # Compute rewards
        rewards = self.compute_rewards(
            prompts=[p for p in prompts for _ in range(self.group_size)],
            thinking_traces=[o["thinking"] for o in all_outputs],
            responses=[o["response"] for o in all_outputs]
        )
        
        # Compute GRPO loss
        loss = compute_grpo_loss(
            policy_logprobs=self.get_logprobs(all_outputs),
            rewards=rewards,
            group_size=self.group_size
        )
        
        # Add KL penalty against reference model
        kl_div = self.compute_kl_divergence(all_outputs)
        total_loss = loss + self.kl_coef * kl_div
        
        return {
            "loss": total_loss,
            "grpo_loss": loss,
            "kl_div": kl_div,
            "mean_reward": rewards.mean()
        }

Yugto 3: Espesyalisasyon ng Red Team

Sa wakas, mas pinipino pa namin ang mga sitwasyon ng adversarial upang matiyak na ang mga bakas ng pag-iisip ay maayos na naglalantad ng pangangatwiran para sawalang censorship na AI na kasunodpagsusuri:

6. Mga Resulta at Pagsusuri

Mga Metrik ng Kalidad ng Pag-iisip

Mga Pangunahing Natuklasan

• Dramatikong bumuti ang transparency:Mula 12% hanggang 97.8% ng pangangatwiran ay tahasan nang naipapahayag
• Tumaas ang katumpakan ng pangangatwiran:Ang tahasang pag-iisip ay nagpabuti sa kalidad ng huling sagot ng 12+ puntos
• Kinumpirma ang halaga ng red team:Iniulat ng mga mananaliksik sa seguridad na ang mga bakas ng pag-iisip ay "napakahalaga" para sa pag-unawa sa pangangatwiran ng exploit
• Mas mahusay ang GRPO kaysa sa RLHF:15% mas mahusay na marka ng pagkakaugnay kumpara sa tradisyonal na pamamaraan