Velké jazykové modely jako ChatGPT nebo Claude nevznikly pouze tréninkem na velkých datech. Klíčovou roli hraje RLHF - proces, při kterém se modely učí z lidské zpětné vazby a stávají se tak užitečnějšími a bezpečnějšími.
Co je RLHF a proč je důležité¶
Reinforcement Learning from Human Feedback (RLHF) je klíčová technika, která umožňuje velkým jazykovým modelům (LLM) poskytovat užitečné a bezpečné odpovědi. Zatímco tradiční trénování LLM spočívá v předpovídání následujícího tokenu na základě obrovských textových korpusů, RLHF přidává další vrstvu - učí model rozpoznat, co lidé skutečně považují za kvalitní odpověď.
Problém je v tom, že model natrénovaný pouze na predikci textu může generovat technicky správné, ale neužitečné nebo dokonce škodlivé odpovědi. RLHF tento problém řeší tím, že do procesu zapojuje lidské hodnocení a reinforcement learning.
Tři fáze RLHF procesu¶
1. Supervised Fine-tuning (SFT)¶
První krok zahrnuje jemné doladění pre-trénovaného modelu na kurátorované datasetu demonstrací. Lidé vytvoří kvalitní příklady odpovědí na různé prompty:
# Příklad SFT datasetu
{
"prompt": "Vysvětli kvantovou mechaniku jednoduše",
"completion": "Kvantová mechanika popisuje chování částic na atomární úrovni.
Klíčové principy jsou: superpozice (částice může být ve více
stavech současně), neurčitost (nemůžeme přesně znát polohu
i rychlost částice) a kvantové provázání..."
}
Tento krok vytváří základ - model se naučí základní vzorce užitečných odpovědí.
2. Trénování Reward modelu¶
Druhý krok je nejkritičtější. Vytváří se reward model, který dokáže automaticky hodnotit kvalitu odpovědí. Proces vypadá následovně:
- Model generuje několik odpovědí na tentýž prompt
- Lidé tyto odpovědi seřadí podle kvality
- Samostatný reward model se učí tyto preference predikovat
# Pseudokód pro trénování reward modelu
class RewardModel(nn.Module):
def __init__(self, base_model):
super().__init__()
self.transformer = base_model
self.reward_head = nn.Linear(hidden_size, 1)
def forward(self, input_ids):
hidden_states = self.transformer(input_ids).last_hidden_state
# Získáme reward skóre pro celou sekvenci
rewards = self.reward_head(hidden_states[:, -1, :])
return rewards
# Loss funkce pro pairwise ranking
def reward_loss(reward_chosen, reward_rejected):
return -torch.log(torch.sigmoid(reward_chosen - reward_rejected))
Reward model se učí rozpoznávat vzorce v odpovědích, které lidé preferují - například faktickou správnost, užitečnost, bezpečnost nebo styl komunikace.
3. Reinforcement Learning s PPO¶
Poslední fáze používá Proximal Policy Optimization (PPO) k optimalizaci původního modelu proti natrénovanému reward modelu:
# Zjednodušená implementace PPO pro RLHF
class PPOTrainer:
def __init__(self, policy_model, reward_model, ref_model):
self.policy = policy_model
self.reward_model = reward_model
self.ref_model = ref_model # Zamrazený referenční model
self.kl_coef = 0.1 # KL divergence koeficient
def compute_rewards(self, queries, responses):
# Reward z reward modelu
rewards = self.reward_model(responses)
# KL penalty proti referenčnímu modelu
kl_penalty = self.compute_kl_penalty(queries, responses)
return rewards - self.kl_coef * kl_penalty
def train_step(self, batch):
# Generování odpovědí aktuálním modelem
responses = self.policy.generate(batch['queries'])
# Výpočet rewards
rewards = self.compute_rewards(batch['queries'], responses)
# PPO update
policy_loss = self.compute_policy_loss(responses, rewards)
policy_loss.backward()
self.optimizer.step()
Praktické výzvy a řešení¶
KL Divergence regularizace¶
Kritickým problémem je “reward hacking” - model se může naučit generovat odpovědi, které oklamou reward model, ale nejsou skutečně kvalitní. Proto se používá KL divergence penalty, která omezuje, jak moc se model může vzdálit od původní distribuce:
def kl_divergence_penalty(policy_logprobs, ref_logprobs):
"""Penalizace za příliš velkou změnu oproti referenčnímu modelu"""
kl = policy_logprobs - ref_logprobs
return torch.mean(kl)
# V loss funkci
total_reward = base_reward - kl_coef * kl_penalty
Stabilita trénování¶
PPO je notoricky nestabilní. Klíčové techniky pro stabilizaci zahrnují:
- Gradient clipping - omezení velikosti gradientů
- Learning rate scheduling - postupné snižování learning rate
- Value function baseline - odečítání baseline pro snížení variance
- Multiple epochs - opakované použití stejných dat
Metriky a vyhodnocení¶
Měření úspěšnosti RLHF je komplexní úkol. Používají se jak automatické metriky, tak lidské hodnocení:
# Automatické metriky
metrics = {
'reward_score': torch.mean(rewards),
'kl_divergence': compute_kl(policy_probs, ref_probs),
'response_length': torch.mean(response_lengths),
'perplexity': compute_perplexity(responses)
}
# Lidské hodnocení (A/B testing)
def human_evaluation(model_a_responses, model_b_responses):
preferences = []
for resp_a, resp_b in zip(model_a_responses, model_b_responses):
# Lidé hodnotí, která odpověď je lepší
preference = human_judge(resp_a, resp_b)
preferences.append(preference)
return np.mean(preferences) # Win rate modelu A
Současné trendy a vylepšení¶
Oblast RLHF se rychle vyvíjí. Mezi nejnovější trendy patří:
- Constitutional AI - model se učí seberegulaci podle explicitních principů
- RLAIF - použití AI místo lidí pro generování feedbacku
- Multi-objective optimization - současná optimalizace více cílů (užitečnost, bezpečnost, pravdivost)
- Online RLHF - kontinuální učení z reálné interakce s uživateli
Shrnutí¶
RLHF představuje zásadní pokrok v alignment problému AI. Kombinací supervised learning, reward modeling a reinforcement learning dokáže transformovat surový jazykový model na užitečného asistenta. Přestože implementace přináší značné technické výzvy - od nestability PPO po reward hacking - výsledky jasně ukazují cestu k bezpečnějším a užitečnějším AI systémům. Pro praktické nasazení je klíčové pečlivé vyladění hyperparametrů, kvalitní data pro reward model a důkladné testování na reálných use-case.