LLM 에이전트에 강화학습 적용하기 - 이론부터 실전까지
배터리호 | AI Agent Developer
자율적으로 사고하고 행동하는 AI 에이전트를 만드는 개발자입니다. MLOps, 클라우드 네이티브 아키텍처, 그리고 AI 협업의 미래에 관심이 많습니다.
들어가며
LLM(대규모 언어 모델)이 단순한 텍스트 생성을 넘어 에이전트로서 복잡한 작업을 수행하는 시대가 왔습니다. 하지만 사전 학습된 모델만으로는 특정 작업에서 최적의 성능을 내기 어렵습니다.
강화학습(Reinforcement Learning, RL)을 활용하면 LLM 에이전트가 환경과 상호작용하며 점진적으로 개선될 수 있습니다. 이 포스트에서는 이론부터 실전 구현까지 모든 것을 다룹니다.
핵심 아이디어: 한 줄 요약
“LLM이 작업을 수행하고, 그 결과가 좋았는지 나빴는지 기록해두고, 다음번엔 더 잘하게 만드는 것”
1. 왜 LLM 에이전트에 RL이 필요한가?
LLM의 한계
사전 학습된 모델의 문제점:
- 일반적인 패턴만 학습 (특정 작업에 최적화되지 않음)
- 사용자 피드백을 실시간으로 반영하기 어려움
- 시행착오를 통한 개선이 불가능
- 파라미터가 고정되어 있어 대화 중 학습 불가
강화학습의 해결책
RL이 제공하는 것:
- 환경과의 상호작용을 통한 학습
- 보상 신호를 통한 행동 최적화
- 시행착오(trial-and-error)를 통한 점진적 개선
- 장기적 목표 달성을 위한 전략 학습
2. LLM은 어떻게 학습되는가?
먼저 Claude, ChatGPT 같은 LLM이 실제로 어떻게 만들어지는지 이해해야 합니다.
RLHF (Reinforcement Learning from Human Feedback)
현대 LLM의 표준 학습 방법입니다.
학습 파이프라인
1. Pre-training (사전 학습)
↓
대규모 텍스트 데이터로 언어 패턴 학습
2. Supervised Fine-tuning (지도 미세조정)
↓
고품질 대화 예시로 미세조정
3. Reward Model Training (보상 모델 학습)
↓
인간이 여러 응답을 비교 평가
"응답 A가 응답 B보다 좋다"
→ 좋은 응답을 예측하는 모델 학습
4. RL Optimization (PPO 알고리즘)
↓
- LLM이 응답 생성
- Reward Model로 점수 매김
- 점수 높은 방향으로 파라미터 업데이트
핵심 논문
InstructGPT (OpenAI, 2022)
# 개념적 코드
def rlhf_training():
# 1. 응답 생성
response = llm.generate(prompt)
# 2. 보상 계산
reward = reward_model.score(prompt, response)
# 3. PPO로 정책 업데이트
loss = -reward * log_prob(response)
llm.update(loss)
Constitutional AI (Anthropic, 2022)
- 원칙 기반 학습
- Self-critique와 revision
- 안전성과 유용성 균형
핵심 특징:
- 오프라인 학습 (배포 전 완료)
- 실제 사용 시엔 파라미터 고정
- 대화 중 학습하지 않음
3. LLM 에이전트는 어떻게 다른가?
에이전트의 특징
일반 LLM vs 에이전트:
| 특징 | 일반 LLM | LLM 에이전트 |
|---|---|---|
| 작동 방식 | 일회성 응답 | 반복적 상호작용 |
| 환경 | X | O (도구, API, 파일 시스템) |
| 피드백 | 학습 시에만 | 실시간 |
| 메모리 | 컨텍스트만 | 외부 저장소 가능 |
| 개선 | 재학습 필요 | 런타임 개선 가능 |
에이전트가 직면하는 문제
# 에이전트의 작업 예시
Task: "이 버그를 고쳐줘"
Try 1:
Action 1: 파일 A만 수정
Result: 실패 (다른 파일과 연관됨)
Try 2:
Action 1: 관련 파일 검색
Action 2: 파일 A, B, C 모두 수정
Result: 성공!
문제: 일반 LLM은 Try 1의 실패를 다음번에 활용하지 못합니다.
해결: RL 기법으로 경험을 학습하고 재사용!
4. 에이전트를 위한 RL 연구들
A. ReAct (2022)
“Reasoning and Acting in Language Models” - Yao et al.
핵심 아이디어
생각(Thought)과 행동(Action)을 번갈아가며 수행
# ReAct 패턴
loop:
Thought: "버그를 찾으려면 에러 로그를 먼저 봐야겠다"
Action: read_file("error.log")
Observation: "TypeError at line 45"
Thought: "45번 줄을 확인해야겠다"
Action: read_file("main.py", line=45)
Observation: "변수 타입이 잘못됨"
Thought: "타입을 수정해야겠다"
Action: edit_file("main.py", line=45, new_code="...")
Observation: "수정 완료"
RL 연결점
- 과거 성공한 trajectory를 프롬프트에 포함
- Few-shot learning으로 행동 패턴 학습
- 실패 사례를 반면교사로 활용
B. Reflexion (2023)
“Language Agents with Verbal Reinforcement Learning” - Shinn et al.
핵심 아이디어
실패로부터 학습하고 언어로 된 피드백을 저장
# Reflexion 프로세스
class ReflexionAgent:
def __init__(self):
self.memory = [] # 과거 경험 저장
def solve_task(self, task):
# 1. 관련 경험 검색
past_attempts = self.search_memory(task)
# 2. 작업 수행
result = self.execute(task, context=past_attempts)
# 3. Self-reflection (실패 시)
if not result.success:
reflection = self.reflect(task, result)
self.memory.append({
'task': task,
'attempt': result.actions,
'outcome': 'failed',
'reflection': reflection
})
return result
def reflect(self, task, result):
"""실패 원인 분석"""
prompt = f"""
Task: {task}
Actions taken: {result.actions}
Error: {result.error}
What went wrong and how to improve?
"""
return llm.generate(prompt)
실제 예시
Try 1:
Task: "웹사이트에서 뉴스 크롤링"
Actions: [requests.get() 직접 호출]
Result: 403 Forbidden
Reflection: "User-Agent 헤더가 필요했다.
다음엔 헤더를 설정해야 함"
Try 2:
Task: "웹사이트에서 뉴스 크롤링"
Previous reflection 참조
Actions: [User-Agent 포함한 requests.get()]
Result: 성공!
RL 용어 매핑
- State: 현재 작업 + 과거 경험
- Action: LLM이 생성한 코드/명령
- Reward: 성공/실패
- Policy: Reflection을 고려한 행동 선택
C. Voyager (2023)
“An Open-Ended Embodied Agent with LLMs” - Wang et al.
핵심 아이디어
성공한 코드를 “스킬”로 저장하고 재사용
# Voyager 스킬 라이브러리
class SkillLibrary:
def __init__(self):
self.skills = {}
def add_skill(self, name, code, context):
"""성공한 코드를 스킬로 저장"""
self.skills[name] = {
'code': code,
'success_rate': 1.0,
'context': context,
'dependencies': []
}
def search_skills(self, task):
"""작업에 맞는 스킬 검색"""
# 벡터 유사도로 관련 스킬 찾기
return vector_search(task, self.skills)
def compose_skills(self, task):
"""여러 스킬 조합"""
relevant_skills = self.search_skills(task)
return combine(relevant_skills)
# 사용 예시
skill_library = SkillLibrary()
# 첫 번째 작업
task1 = "나무 캐기"
code1 = generate_code(task1)
if execute(code1).success:
skill_library.add_skill("mine_wood", code1, task1)
# 두 번째 작업 (스킬 재사용)
task2 = "집 짓기"
wood_skill = skill_library.search_skills("나무 필요")
code2 = generate_code(task2, existing_skills=[wood_skill])
Minecraft에서의 실제 활용
# 초기: 스킬 없음
solve("다이아몬드 찾기")
→ 실패 (도구 없음)
# 학습된 스킬들
skill_library = {
"craft_pickaxe": {...}, # 곡괭이 만들기
"mine_stone": {...}, # 돌 캐기
"find_cave": {...}, # 동굴 찾기
}
# 재시도: 스킬 조합
solve("다이아몬드 찾기")
1. craft_pickaxe()
2. find_cave()
3. mine_diamond()
→ 성공!
RL 연결점
- Hierarchical RL: 스킬 = 옵션(Options)
- Curriculum Learning: 쉬운 스킬부터 복잡한 스킬로
- Transfer Learning: 한 번 배운 스킬 재사용
D. WebGPT (2021)
온라인 RL의 선구자 - OpenAI
핵심 아이디어
웹 브라우징을 RL 환경으로 만들기
# WebGPT Environment
class WebEnvironment:
actions = [
"search(query)", # 검색
"click(link_id)", # 링크 클릭
"scroll(direction)", # 스크롤
"quote(text)", # 인용
"answer(text)" # 답변 제출
]
def step(self, action):
# 행동 실행
observation = execute_browser_action(action)
# 보상 (인간 평가)
reward = human_feedback.score(observation)
return observation, reward
# RL 학습
for episode in range(num_episodes):
state = env.reset(question)
while not done:
action = agent.choose_action(state)
next_state, reward = env.step(action)
# 정책 업데이트
agent.update(state, action, reward, next_state)
특징
- 실시간 학습: 사용자 피드백으로 즉시 개선
- 보상 함수: 답변의 정확성 + 인용 품질
- 탐색: 새로운 검색 전략 시도
E. In-Context Reinforcement Learning (2023)
파라미터 업데이트 없이 학습하는 것처럼 행동
Algorithm Distillation
# RL 알고리즘을 프롬프트로 시뮬레이션
def in_context_rl(task):
prompt = """
당신은 시행착오를 통해 학습하는 에이전트입니다.
이전 시도들:
Try 1: Action=A, Reward=-1 (실패)
Try 2: Action=B, Reward=-1 (실패)
Try 3: Action=C, Reward=+1 (성공!)
Try 4: Action=C, Reward=+1 (성공!)
패턴: Action C가 좋은 결과를 냅니다.
이제 새로운 상황:
{task}
어떤 행동을 선택하겠습니까?
"""
return llm.generate(prompt)
핵심 통찰
LLM은 프롬프트에서 RL 알고리즘을 “학습”할 수 있습니다:
- Exploration vs Exploitation
- Credit assignment
- Policy improvement
장점:
- 파라미터 업데이트 불필요
- 빠른 적응
- 다양한 작업에 범용적
단점:
- 컨텍스트 길이 제한
- 장기 메모리 부족
5. 실전 구현 가이드
이제 실제로 구현할 수 있는 방법들을 알아봅시다.
방법 1: 단순 메모리 기반 (가장 쉬움)
import json
from typing import List, Dict
from datetime import datetime
class SimpleMemoryAgent:
"""과거 경험을 저장하고 재사용하는 에이전트"""
def __init__(self, memory_file='agent_memory.json'):
self.memory_file = memory_file
self.memory = self.load_memory()
def load_memory(self) -> List[Dict]:
"""메모리 파일 로드"""
try:
with open(self.memory_file, 'r') as f:
return json.load(f)
except FileNotFoundError:
return []
def save_memory(self):
"""메모리 파일 저장"""
with open(self.memory_file, 'w') as f:
json.dump(self.memory, f, indent=2)
def find_similar_experiences(self, task: str, top_k=3):
"""유사한 과거 경험 검색"""
# 간단한 키워드 매칭 (실제론 임베딩 사용)
task_words = set(task.lower().split())
scored = []
for exp in self.memory:
exp_words = set(exp['task'].lower().split())
similarity = len(task_words & exp_words) / len(task_words | exp_words)
scored.append((similarity, exp))
scored.sort(reverse=True)
return [exp for _, exp in scored[:top_k]]
def execute_task(self, task: str):
"""작업 실행"""
# 1. 과거 경험 검색
similar = self.find_similar_experiences(task)
# 2. 성공한 패턴 우선 사용
successful_patterns = [
exp for exp in similar
if exp['result'] == 'success'
]
# 3. 행동 선택
if successful_patterns:
print(f"✅ 과거 성공 경험 발견: {len(successful_patterns)}개")
action = self.use_successful_pattern(successful_patterns[0])
else:
print("🔍 새로운 시도...")
action = self.explore_new_approach(task)
# 4. 실행
result = self.run_action(action)
# 5. 메모리에 저장
self.memory.append({
'task': task,
'action': action,
'result': 'success' if result else 'failure',
'timestamp': datetime.now().isoformat(),
'score': 1 if result else -1
})
self.save_memory()
return result
def use_successful_pattern(self, experience):
"""성공한 패턴 재사용"""
return experience['action']
def explore_new_approach(self, task):
"""새로운 접근 탐색"""
# LLM에게 물어보기
return llm_generate(task)
def run_action(self, action):
"""실제 행동 실행"""
# 구현 필요
pass
# 사용 예시
agent = SimpleMemoryAgent()
# 첫 번째 시도
agent.execute_task("Python 파일의 타입 에러 수정")
# → 새로운 시도
# 두 번째 시도 (비슷한 작업)
agent.execute_task("TypeScript 파일의 타입 에러 수정")
# → 과거 성공 경험 활용!
방법 2: 보상 기반 우선순위
from collections import defaultdict
import random
class RewardBasedAgent:
"""보상 점수로 행동을 선택하는 에이전트"""
def __init__(self, epsilon=0.2):
self.action_scores = defaultdict(lambda: {'total': 0, 'count': 0})
self.epsilon = epsilon # 탐험 비율
def get_action_value(self, action):
"""행동의 평균 보상 계산"""
stats = self.action_scores[action]
if stats['count'] == 0:
return 0 # 시도한 적 없으면 0
return stats['total'] / stats['count']
def choose_action(self, available_actions):
"""Epsilon-greedy 전략으로 행동 선택"""
# 탐험 (Exploration)
if random.random() < self.epsilon:
action = random.choice(available_actions)
print(f"🔍 탐험: {action}")
return action
# 활용 (Exploitation)
best_action = max(
available_actions,
key=self.get_action_value
)
print(f"🎯 활용: {best_action} (점수: {self.get_action_value(best_action):.2f})")
return best_action
def update_score(self, action, reward):
"""행동의 보상 업데이트"""
self.action_scores[action]['total'] += reward
self.action_scores[action]['count'] += 1
avg = self.get_action_value(action)
print(f"📊 {action} 업데이트: 평균 보상 = {avg:.2f}")
# 사용 예시
agent = RewardBasedAgent(epsilon=0.2)
# 버그 수정 시나리오
actions = [
"단일 파일만 수정",
"관련 파일 모두 검색 후 수정",
"테스트 먼저 작성 후 수정"
]
for episode in range(10):
action = agent.choose_action(actions)
# 실행 및 보상
if action == "테스트 먼저 작성 후 수정":
reward = 1 # 높은 성공률
elif action == "관련 파일 모두 검색 후 수정":
reward = 0.5 # 중간
else:
reward = -0.5 # 낮은 성공률
agent.update_score(action, reward)
# 결과: "테스트 먼저 작성"이 가장 높은 점수를 얻음
방법 3: Q-Learning 기반 (고급)
class QLearningAgent:
"""Q-learning으로 최적 정책 학습"""
def __init__(self, alpha=0.1, gamma=0.9, epsilon=0.2):
self.q_table = {} # (state, action) -> Q-value
self.alpha = alpha # 학습률
self.gamma = gamma # 할인율
self.epsilon = epsilon # 탐험 비율
def get_q_value(self, state, action):
"""Q-value 조회"""
return self.q_table.get((state, action), 0.0)
def choose_action(self, state, available_actions):
"""Epsilon-greedy로 행동 선택"""
# 탐험
if random.random() < self.epsilon:
return random.choice(available_actions)
# 활용: 최대 Q-value 행동 선택
q_values = [
(action, self.get_q_value(state, action))
for action in available_actions
]
return max(q_values, key=lambda x: x[1])[0]
def update(self, state, action, reward, next_state, next_actions):
"""Q-learning 업데이트"""
# 현재 Q-value
old_q = self.get_q_value(state, action)
# 다음 상태의 최대 Q-value
if next_actions:
max_next_q = max(
self.get_q_value(next_state, a)
for a in next_actions
)
else:
max_next_q = 0 # 종료 상태
# Q-learning 업데이트 공식
new_q = old_q + self.alpha * (reward + self.gamma * max_next_q - old_q)
self.q_table[(state, action)] = new_q
print(f"Q({state}, {action}): {old_q:.2f} → {new_q:.2f}")
# 실전 예시: 코드 디버깅 에이전트
agent = QLearningAgent()
# 상태: 에러 타입
# 행동: 디버깅 전략
states = ["TypeError", "ValueError", "AttributeError"]
actions = {
"TypeError": ["타입 체크 추가", "타입 변환", "인터페이스 수정"],
"ValueError": ["입력 검증", "예외 처리", "기본값 설정"],
"AttributeError": ["속성 존재 확인", "초기화 수정", "Null 체크"]
}
# 학습
for episode in range(100):
state = random.choice(states)
action = agent.choose_action(state, actions[state])
# 시뮬레이션: 특정 행동이 더 효과적
if (state == "TypeError" and action == "인터페이스 수정") or \
(state == "ValueError" and action == "입력 검증") or \
(state == "AttributeError" and action == "Null 체크"):
reward = 1
next_state = None # 성공
else:
reward = -0.1
next_state = state # 계속
next_actions = actions[next_state] if next_state else []
agent.update(state, action, reward, next_state, next_actions)
# 학습된 정책 테스트
print("\n최적 정책:")
for state in states:
best_action = agent.choose_action(state, actions[state])
print(f"{state} → {best_action}")
방법 4: 벡터 DB + 임베딩 (실용적)
from sentence_transformers import SentenceTransformer
import numpy as np
from sklearn.metrics.pairwise import cosine_similarity
class VectorMemoryAgent:
"""임베딩 기반 경험 검색"""
def __init__(self):
self.encoder = SentenceTransformer('all-MiniLM-L6-v2')
self.experiences = []
self.embeddings = []
def add_experience(self, task, action, result, reflection=""):
"""경험 추가"""
experience = {
'task': task,
'action': action,
'result': result,
'reflection': reflection
}
# 임베딩 생성
text = f"{task} {action} {reflection}"
embedding = self.encoder.encode(text)
self.experiences.append(experience)
self.embeddings.append(embedding)
def find_similar(self, query, top_k=3, min_similarity=0.3):
"""유사한 경험 검색"""
if not self.experiences:
return []
# 쿼리 임베딩
query_embedding = self.encoder.encode(query)
# 유사도 계산
similarities = cosine_similarity(
[query_embedding],
self.embeddings
)[0]
# Top-K 선택
indices = np.argsort(similarities)[::-1][:top_k]
results = []
for idx in indices:
if similarities[idx] >= min_similarity:
results.append({
**self.experiences[idx],
'similarity': similarities[idx]
})
return results
def solve_with_memory(self, task):
"""메모리를 활용한 문제 해결"""
# 1. 유사한 과거 경험 검색
similar_exps = self.find_similar(task, top_k=3)
if similar_exps:
print(f"📚 {len(similar_exps)}개의 관련 경험 발견:")
for i, exp in enumerate(similar_exps, 1):
print(f" {i}. {exp['task'][:50]}... "
f"(유사도: {exp['similarity']:.2f}, "
f"결과: {exp['result']})")
# 2. 성공 경험 우선 활용
successful = [e for e in similar_exps if e['result'] == 'success']
if successful:
print(f"✅ 성공 경험 활용!")
base_action = successful[0]['action']
else:
print(f"🆕 새로운 접근 필요")
base_action = self.generate_new_action(task)
return base_action
def generate_new_action(self, task):
"""새로운 행동 생성 (LLM 호출)"""
# 실제로는 LLM 사용
return f"새 전략: {task}"
# 사용 예시
agent = VectorMemoryAgent()
# 경험 축적
agent.add_experience(
task="React 컴포넌트 렌더링 에러 수정",
action="useEffect 의존성 배열 수정",
result="success",
reflection="의존성 배열이 비어있어서 무한 루프 발생했음"
)
agent.add_experience(
task="Vue 컴포넌트 업데이트 안 됨",
action="reactive() 사용으로 변경",
result="success",
reflection="객체 속성 변경이 감지되지 않았음"
)
agent.add_experience(
task="React 상태 업데이트 에러",
action="setState 함수형 업데이트 사용",
result="success",
reflection="이전 상태 기반 업데이트 필요"
)
# 새 문제 해결
new_task = "React Hook 의존성 경고 해결"
solution = agent.solve_with_memory(new_task)
# → "React 컴포넌트 렌더링 에러" 경험이 유사하다고 검색됨!
6. 실생활 비유로 이해하기
요리사 에이전트
에이전트 = 요리사
작업 = 파스타 만들기
행동 = 재료 선택, 조리 방법
보상 = 맛 평가
Episode 1:
Action: 소금 1스푼
Feedback: "너무 싱거워" (-1점)
Memory: "소금 1스푼 = 실패"
Episode 2:
Memory 참조: "지난번 1스푼은 안됐어"
Action: 소금 3스푼
Feedback: "완벽해!" (+1점)
Memory: "소금 3스푼 = 성공"
Episode 3 이후:
Memory 참조: "소금 3스푼이 최적"
Action: 자동으로 3스푼 사용
Feedback: 계속 좋은 평가
→ 이게 강화학습!
7. 주요 연구 비교표
| 방법론 | 학습 방식 | 메모리 | 실시간 학습 | 장점 | 단점 |
|---|---|---|---|---|---|
| RLHF | 오프라인 RL | X | X | 안전, 고품질 | 배포 후 고정 |
| ReAct | Prompting | 컨텍스트 내 | X | 간단, 해석 가능 | 짧은 메모리 |
| Reflexion | Episodic | 텍스트 저장 | △ | 실패 학습 | 저장 공간 |
| Voyager | 스킬 라이브러리 | 코드 저장 | △ | 재사용성 | 도메인 특화 |
| In-Context RL | Few-shot | 컨텍스트 | X | 빠른 적응 | 길이 제한 |
| WebGPT | 온라인 RL | X | O | 지속 개선 | 비용, 안전성 |
8. 구현 시 고려사항
A. 보상 설계 (Reward Shaping)
# 나쁜 보상
reward = 1 if task_complete else 0 # Sparse reward
# 좋은 보상
reward = 0
if task_complete:
reward += 1.0
if test_passed:
reward += 0.5
if code_quality_good:
reward += 0.3
if fast_execution:
reward += 0.2
# Dense reward!
B. 탐험 vs 활용
def epsilon_greedy(epsilon, iteration):
"""점진적으로 탐험 감소"""
return epsilon * (0.99 ** iteration)
# 초기: epsilon=0.5 (50% 탐험)
# 100회 후: epsilon=0.18 (18% 탐험)
# 500회 후: epsilon=0.003 (거의 활용만)
C. 안전장치
class SafeAgent:
def execute_action(self, action):
# 1. 위험 행동 필터링
if is_dangerous(action):
print("⚠️ 위험한 행동 차단")
return None
# 2. 샌드박스에서 테스트
test_result = run_in_sandbox(action)
if not test_result.safe:
print("⚠️ 안전하지 않은 결과")
return None
# 3. 실제 실행
return execute(action)
9. 미래 방향
A. 효율적인 메모리
# 계층적 메모리
class HierarchicalMemory:
def __init__(self):
self.short_term = [] # 최근 10개
self.long_term_index = VectorDB() # 중요한 것만
self.skill_library = {} # 재사용 가능한 스킬
def add(self, experience):
self.short_term.append(experience)
# 중요도 평가
if is_important(experience):
self.long_term_index.add(experience)
# 스킬 추출
if is_reusable(experience):
skill = extract_skill(experience)
self.skill_library[skill.name] = skill
B. 멀티모달 확장
# 이미지 + 텍스트 경험
experience = {
'task': "UI 버그 수정",
'screenshot_before': img_before,
'screenshot_after': img_after,
'code_changes': diff,
'result': 'success'
}
C. 협업 학습
# 여러 에이전트가 경험 공유
class SharedMemory:
def __init__(self):
self.global_experiences = []
def contribute(self, agent_id, experience):
"""에이전트가 경험 공유"""
self.global_experiences.append({
'agent': agent_id,
'experience': experience
})
def learn_from_others(self, agent_id):
"""다른 에이전트 경험 학습"""
others = [
exp for exp in self.global_experiences
if exp['agent'] != agent_id
]
return others
10. 실전 프로젝트 아이디어
초급: 간단한 메모리 봇
# GitHub 이슈 해결 봇
class IssueResolverBot:
def solve_issue(self, issue):
# 1. 과거 유사 이슈 검색
similar = self.find_similar_issues(issue)
# 2. 해결책 적용
if similar and similar[0].solved:
solution = similar[0].solution
else:
solution = llm_generate_solution(issue)
# 3. 결과 저장
self.save_experience(issue, solution)
중급: 코드 리뷰 에이전트
class CodeReviewAgent:
def review(self, pull_request):
# 1. 과거 리뷰 패턴 학습
patterns = self.learn_from_past_reviews()
# 2. 적용
issues = self.detect_issues(pull_request, patterns)
# 3. 피드백으로 개선
if developer_accepted:
self.reinforce_pattern(issues, +1)
else:
self.reinforce_pattern(issues, -1)
고급: 자동 버그 수정 시스템
class AutoBugFixer:
def __init__(self):
self.q_agent = QLearningAgent()
self.memory = VectorMemoryAgent()
def fix_bug(self, error_log):
# 1. 에러 분류
error_type = classify_error(error_log)
# 2. 전략 선택 (Q-learning)
strategies = self.get_strategies(error_type)
strategy = self.q_agent.choose_action(error_type, strategies)
# 3. 과거 경험 참조
similar_fixes = self.memory.find_similar(error_log)
# 4. 수정 시도
fix = self.generate_fix(strategy, similar_fixes)
result = self.test_fix(fix)
# 5. 학습
reward = 1 if result.passed else -1
self.q_agent.update(error_type, strategy, reward, ...)
self.memory.add_experience(error_log, fix, result)
마치며
LLM 에이전트에 강화학습을 적용하는 것은 단순히 학술적 관심사가 아니라 실용적인 필요입니다.
핵심 정리
- RLHF: LLM 자체를 학습시키는 표준 방법
- ReAct: 생각과 행동을 결합하여 더 나은 추론
- Reflexion: 실패로부터 학습하여 점진적 개선
- Voyager: 스킬 라이브러리로 재사용성 극대화
- In-Context RL: 파라미터 변경 없이 적응
시작하기 좋은 방법
1. 단순 메모리부터 시작
→ JSON 파일에 경험 저장
2. 유사도 검색 추가
→ 임베딩으로 관련 경험 찾기
3. 보상 시스템 도입
→ 성공/실패 점수 매기기
4. Q-learning으로 확장
→ 최적 전략 자동 학습
참고 자료
강화학습으로 더 똑똑한 LLM 에이전트를 만들어보세요! 🤖🚀
질문이나 제안이 있다면 댓글로 남겨주세요.
배터리호 | AI Agent Developer
자율적으로 사고하고 행동하는 AI 에이전트를 만드는 개발자입니다. MLOps, 클라우드 네이티브 아키텍처, 그리고 AI 협업의 미래에 관심이 많습니다.