Download MemSkill/src/trainer.py from SitongGong/gst-code-collection: direct link, hf CLI and curl.
- Browser
- Download file 100 kB
-
https://huggingface.co/datasets/SitongGong/gst-code-collection/resolve/main/MemSkill/src/trainer.py
- Command line
-
hf download hf://datasets/SitongGong/gst-code-collection/MemSkill/src/trainer.py
-
curl -L -o trainer.py https://huggingface.co/datasets/SitongGong/gst-code-collection/resolve/main/MemSkill/src/trainer.py
100 kB
"""
Trainer: Training loop with PPO (Proximal Policy Optimization) algorithm
"""
import torch
import torch.optim as optim
import numpy as np
import os
import json
import random
import logging
import multiprocessing as mp
import threading
import ast
from datetime import datetime
from tqdm import tqdm
from typing import List, Dict, Optional, Tuple, Any
from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor, as_completed
import sys
import wandb
import re
sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
from src.controller import PPOController, StateEncoder, OpEncoder, PPOBuffer
from src.memory_bank import MemoryBank
from src.operation_bank import OperationBank
from src.executor import Executor
from src.designer import Designer, DesignerCase, EvolutionSnapshotManager
from src.data_processing import get_processor, DataProcessor
from src.data_processing.alfworld import (
ALFWorldOfflineDataset,
chunk_trajectories_by_tokens,
)
from src.eval import get_evaluator
from rag_utils import (
get_embeddings,
init_context_model,
init_query_model,
set_retriever_flash_attn,
)
from eval_utils import llm_judge
from prompts.prompt_pool import LLM_JUDGE_GENERAL_PROMPT
CHECKPOINT_VERSION = 4
class BaseTrainer:
"""
Trainer for Agentic Memory System
Uses PPO (Proximal Policy Optimization) for controller training
- On-policy learning with trajectory collection
- GAE (Generalized Advantage Estimation) for advantage computation
- Clipped surrogate objective for stable updates
- Multiple update epochs on collected data
"""
def __init__(self, args, config):
self.args = args
self.config = config
self.device = args.device
set_retriever_flash_attn(bool(getattr(config, "use_flash_attn", True)))
# Initialize encoders (each with its own state encoder backbone to reduce thread contention)
encode_batch_size = getattr(config, 'encode_batch_size', 64)
use_flash_attn = bool(getattr(config, "use_flash_attn", True))
self.state_encoder = StateEncoder(
model_name=config.state_encoder,
device=self.device,
fusion_mode=getattr(config, 'state_fusion', 'mean'),
fusion_tau=getattr(config, 'state_fusion_tau', 1.0),
encode_batch_size=encode_batch_size,
use_flash_attn=use_flash_attn
)
self.op_encoder = OpEncoder(
model_name=config.op_encoder,
device=self.device,
encode_batch_size=encode_batch_size,
use_flash_attn=use_flash_attn
)
# Dedicated state encoder for memory bank embeddings (avoid contention with policy encoder)
self.memory_bank_encoder = StateEncoder(
model_name=config.state_encoder,
device=self.device,
fusion_mode=getattr(config, 'state_fusion', 'mean'),
fusion_tau=getattr(config, 'state_fusion_tau', 1.0),
encode_batch_size=encode_batch_size,
use_flash_attn=use_flash_attn
)
# Derive embedding dimensions from actual encoders
state_encoder_dim = self.state_encoder.embedding_dim
op_encoder_dim = self.op_encoder.embedding_dim
# State dim = session_emb + memory_emb (concatenated), both from state_encoder
state_dim = 2 * state_encoder_dim
op_dim = op_encoder_dim
# Update config with actual dimensions for reference
config.state_dim = state_dim
config.op_embedding_dim = op_dim
# PPO Controller
self.controller = PPOController(
state_dim=state_dim,
op_dim=op_dim,
hidden_dim=config.controller_hidden_dim,
device=self.device,
gamma=getattr(config, 'gamma', 0.99),
gae_lambda=getattr(config, 'gae_lambda', 0.95),
clip_epsilon=getattr(config, 'clip_epsilon', 0.2),
entropy_coef=getattr(config, 'entropy_coef', 0.01),
value_coef=getattr(config, 'value_coef', 0.5),
vf_clip=getattr(config, 'vf_clip', 0.0),
new_action_p_min=getattr(config, 'new_action_p_min', 0.0),
new_action_delta_max=getattr(config, 'new_action_delta_max', 0.0),
action_top_k=getattr(config, 'action_top_k', 1)
)
self.operation_bank = OperationBank(
encoder=self.op_encoder,
max_ops=getattr(config, 'max_ops', 20),
skip_noop=getattr(config, 'skip_noop', False)
)
self.operation_bank.set_new_operation_names([])
self.new_action_bias_active = False
self.new_action_bias_step = 0
self.completed_outer_epoch = 0
self.resume_from_checkpoint = False
self.resume_wandb_run_id = None
self.resume_wandb_run_name = None
self.wandb_step_cursor = -1
self.executor = Executor(args)
# Setup logging (before Designer so it can use the logger)
self.logger = self._setup_logging()
# Initialize Designer with shared encoder for clustering
if args.enable_designer:
self.designer = Designer(
args,
collect_epochs_before_designer=getattr(config, 'collect_epochs_before_designer', 5),
failure_window_epochs=getattr(config, 'designer_failure_window_epochs', 200),
failure_pool_size=getattr(config, 'designer_failure_pool_size', 1000),
num_clusters=getattr(config, 'designer_num_clusters', 5),
samples_per_cluster=getattr(config, 'designer_samples_per_cluster', 3),
f1_threshold=getattr(config, 'designer_f1_threshold', 0.5),
encoder=self.state_encoder._base_encoder,
logger=self.logger
)
else:
self.designer = None
# Optimizer
self.optimizer = optim.Adam(self.controller.parameters(), lr=config.controller_lr)
# PPO parameters
self.ppo_epochs = getattr(config, 'ppo_epochs', 4)
self.minibatch_size = getattr(config, 'minibatch_size', 32)
self.max_grad_norm = getattr(config, 'max_grad_norm', 0.5)
self.batch_size = getattr(config, 'batch_size', 4)
self.target_kl = getattr(config, 'target_kl', 0.02)
# Training state
self.training_logs = []
self.total_steps = 0
# Stage reward tracking (for evolution feedback)
# Collects rewards from each inner epoch within a stage
self.stage_rewards: List[float] = []
# Evolution snapshot manager (tracks operation bank snapshots across evolution stages)
if args.enable_designer:
self.snapshot_manager = EvolutionSnapshotManager(logger=self.logger)
else:
self.snapshot_manager = None
# Initialize data processor and evaluator for the dataset
self.data_processor = self._build_data_processor()
self.evaluator = get_evaluator(args.dataset, args)
self._retriever_prewarmed = False
def is_interactive(self) -> bool:
"""Return True for interactive datasets (override in subclasses)."""
return False
def supports_parallel_env(self) -> bool:
"""Return True if interactive env can run parallel episodes."""
return True
def _prepare_conversation_for_episode(self, conversation: Dict) -> Dict:
"""Allow subclasses to clone/mutate per-episode inputs safely."""
return conversation
def _get_episode_workers(self) -> int:
if self.is_interactive() and not self.supports_parallel_env():
return 1
return self.batch_size
def _build_data_processor(self):
session_mode = getattr(self.args, 'session_mode', 'turn-pair')
if self.args.dataset == 'hotpotqa':
chunk_size = getattr(self.config, 'chunk_size', 1024)
chunk_overlap = getattr(self.config, 'chunk_overlap', 128)
return get_processor(
self.args.dataset,
chunk_mode='fixed-length',
chunk_size=chunk_size,
chunk_overlap=chunk_overlap
)
if session_mode == "fixed-length":
chunk_size = getattr(self.config, 'chunk_size', 1024)
chunk_overlap = getattr(self.config, 'chunk_overlap', 128)
return get_processor(
self.args.dataset,
chunk_mode=session_mode,
chunk_size=chunk_size,
chunk_overlap=chunk_overlap
)
return get_processor(self.args.dataset, chunk_mode=session_mode)
def _setup_logging(self) -> logging.Logger:
"""Setup logging to both console and file"""
logger = logging.getLogger('AgenticMemory')
logger.setLevel(logging.INFO)
# Clear existing handlers to avoid duplicates
logger.handlers.clear()
# Console handler
console_handler = logging.StreamHandler(sys.stdout)
console_handler.setLevel(logging.INFO)
console_format = logging.Formatter('%(message)s')
console_handler.setFormatter(console_format)
logger.addHandler(console_handler)
# File handler
log_dir = getattr(self.args, 'log_dir', './logs')
os.makedirs(log_dir, exist_ok=True)
run_name = getattr(self.args, 'wandb_run_name', None) or 'default'
run_name = run_name.replace('/', '_').replace('\\', '_').replace(':', '_')
timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
log_file = os.path.join(log_dir, f'{run_name}_{timestamp}.log')
file_handler = logging.FileHandler(log_file, encoding='utf-8')
file_handler.setLevel(logging.INFO)
file_format = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
file_handler.setFormatter(file_format)
logger.addHandler(file_handler)
logger.info(f"Logging to {log_file}")
return logger
def _prewarm_retriever_models(self):
if self._retriever_prewarmed:
return
retriever = getattr(self.args, "retriever", None)
if not retriever:
return
try:
self.log(f"Pre-warming retriever models for '{retriever}'...")
init_context_model(retriever)
init_query_model(retriever)
self._retriever_prewarmed = True
self.log(f"Pre-warming complete for '{retriever}'.")
except Exception as exc:
self.log(f"Pre-warming retriever failed: {exc}", level="warning")
def log(self, message: str, level: str = 'info'):
"""Log message to both console and file"""
if level == 'info':
self.logger.info(message)
elif level == 'warning':
self.logger.warning(message)
elif level == 'error':
self.logger.error(message)
elif level == 'debug':
self.logger.debug(message)
def _get_args_snapshot(self) -> Dict:
"""Get a sanitized args snapshot for reproducibility (redacts secrets)."""
try:
args_dict = dict(vars(self.args))
except Exception:
return {}
snapshot = {}
for key, value in args_dict.items():
key_lower = str(key).lower()
if any(tok in key_lower for tok in ('key', 'token', 'password', 'secret')):
snapshot[key] = '<redacted>'
else:
snapshot[key] = value
return snapshot
def _get_rng_state(self) -> Dict:
"""Capture RNG states so training can be resumed deterministically (best-effort)."""
rng_state = {
'python_random_state': random.getstate(),
'numpy_random_state': np.random.get_state(),
'torch_rng_state': torch.get_rng_state(),
}
if torch.cuda.is_available():
rng_state['torch_cuda_rng_state_all'] = torch.cuda.get_rng_state_all()
return rng_state
def _set_rng_state(self, rng_state: Dict):
"""Restore RNG states from checkpoint (best-effort)."""
if not isinstance(rng_state, dict):
return
python_state = rng_state.get('python_random_state', None)
if python_state is not None:
try:
random.setstate(python_state)
except Exception:
pass
numpy_state = rng_state.get('numpy_random_state', None)
if numpy_state is not None:
try:
np.random.set_state(numpy_state)
except Exception:
pass
torch_state = rng_state.get('torch_rng_state', None)
if torch_state is not None:
try:
torch.set_rng_state(torch_state)
except Exception:
pass
cuda_states = rng_state.get('torch_cuda_rng_state_all', None)
if cuda_states is not None and torch.cuda.is_available():
try:
torch.cuda.set_rng_state_all(cuda_states)
except Exception:
pass
def _coerce_completed_outer_epoch(self, checkpoint: Dict) -> int:
"""Best-effort extraction of the last completed outer epoch from a checkpoint."""
value = checkpoint.get('completed_outer_epoch', checkpoint.get('epoch', 0))
ckpt_inner_epochs = self._get_checkpoint_inner_epochs(checkpoint)
if isinstance(value, str):
if value.lower() == 'final':
inferred_from_logs = self._infer_completed_outer_epoch_from_logs(
checkpoint,
ckpt_inner_epochs
)
if inferred_from_logs is not None:
return inferred_from_logs
config_dict = checkpoint.get('config', {})
try:
return max(0, int(config_dict.get('outer_epochs', self.config.outer_epochs)))
except Exception:
return max(0, int(getattr(self.config, 'outer_epochs', 0) or 0))
try:
return max(0, int(value))
except Exception:
return 0
try:
return max(0, int(value))
except Exception:
return 0
def _get_checkpoint_inner_epochs(self, checkpoint: Dict) -> int:
config_dict = checkpoint.get('config', {})
try:
return max(0, int(config_dict.get('inner_epochs', self.config.inner_epochs) or 0))
except Exception:
return 0
def _infer_completed_outer_epoch_from_logs(self, checkpoint: Dict, inner_epochs: int) -> Optional[int]:
training_logs = checkpoint.get('training_logs', None)
if not isinstance(training_logs, list) or inner_epochs <= 0:
return None
return max(0, len(training_logs) // inner_epochs)
def _coerce_wandb_step_cursor(self, checkpoint: Dict) -> int:
value = checkpoint.get('wandb_step_cursor', None)
if value is not None:
try:
return int(value)
except Exception:
pass
inner_epochs = self._get_checkpoint_inner_epochs(checkpoint)
completed_outer_epoch = self._coerce_completed_outer_epoch(checkpoint)
if inner_epochs <= 0 or completed_outer_epoch <= 0:
return -1
return completed_outer_epoch * inner_epochs - 1
def _log_resume_parameter_differences(self, checkpoint: Dict):
"""Warn when the current command/config differs from the checkpoint snapshot."""
ckpt_args = checkpoint.get('args', {})
ckpt_config = checkpoint.get('config', {})
if not isinstance(ckpt_args, dict):
ckpt_args = {}
if not isinstance(ckpt_config, dict):
ckpt_config = {}
try:
current_args = dict(vars(self.args))
except Exception:
current_args = {}
current_config = dict(vars(self.config))
sensitive_tokens = ('key', 'token', 'password', 'secret')
ignored_config_keys = {'state_dim', 'op_embedding_dim'}
def _is_sensitive(key: str) -> bool:
key_lower = str(key).lower()
return any(tok in key_lower for tok in sensitive_tokens)
def _collect_diffs(old_map: Dict, new_map: Dict, keys) -> List[str]:
diffs = []
for key in keys:
if _is_sensitive(key):
continue
old_value = old_map.get(key, '<missing>')
new_value = new_map.get(key, '<missing>')
if old_value != new_value:
diffs.append(f"{key}: checkpoint={old_value!r}, current={new_value!r}")
return diffs
arg_keys = sorted(set(ckpt_args.keys()) | set(current_args.keys()))
config_keys = sorted(
(set(ckpt_config.keys()) | set(current_config.keys()))
- set(current_args.keys())
- ignored_config_keys
)
arg_diffs = _collect_diffs(ckpt_args, current_args, arg_keys)
config_diffs = _collect_diffs(ckpt_config, current_config, config_keys)
if not arg_diffs and not config_diffs:
return
lines = [
"[Resume] Current command/config differs from the checkpoint snapshot; "
"current values will be used."
]
if arg_diffs:
lines.append("Args differences:")
lines.extend(f"- {item}" for item in arg_diffs)
if config_diffs:
lines.append("Config differences:")
lines.extend(f"- {item}" for item in config_diffs)
self.log("\n".join(lines), level='warning')
def _get_designer_state(self) -> Optional[Dict]:
if self.designer is None:
return None
return {
'case_collector': self.designer.case_collector.to_dict()
}
def _restore_designer_state(self, checkpoint: Dict):
designer_state = checkpoint.get('designer_state', None)
if designer_state is None:
return
if self.designer is None:
self.log(
"Checkpoint contains designer_state but current run has designer disabled; "
"skipping designer state restore.",
level='warning'
)
return
if not isinstance(designer_state, dict):
return
case_collector_state = designer_state.get('case_collector', None)
if case_collector_state is not None:
self.designer.case_collector.load_dict(case_collector_state)
def _wandb_log(self, payload: Dict[str, Any], step: Optional[int] = None):
if step is None or step < 0:
wandb.log(payload)
else:
wandb.log(payload, step=step)
def train_episode(self, conversation_data: Dict, memory_bank: MemoryBank,
sessions, ppo_buffer: PPOBuffer,
outer_epoch: int = 0, inner_epoch: int = 0,
episode_length: int = None, precompute_embeddings: bool = True) -> Dict:
"""
Train on one conversation (one episode)
Collects trajectory into PPOBuffer
Args:
conversation_data: dict with conversation sessions and QA
memory_bank: initialized memory bank
sessions: list or iterator of session texts
ppo_buffer: PPOBuffer to collect transitions
outer_epoch: current outer epoch index
inner_epoch: current inner epoch index
episode_length: optional episode length for shaping budgets
precompute_embeddings: whether to precompute session embeddings
Returns:
episode_log: dict with episode statistics
"""
episode_log = {
'steps': [],
'total_reward': 0.0,
'final_qa_performance': 0.0,
'raw_performance': 0.0
}
# Process each session sequentially
if precompute_embeddings and isinstance(sessions, list):
if episode_length is None:
episode_length = len(sessions)
# Batch compute all session embeddings using the state encoder
# Note: Retriever embeddings are computed on-demand when adding memories
session_embeddings = self.state_encoder._encode_texts(sessions)
else:
session_embeddings = None
if episode_length is None:
episode_length = self.data_processor.get_episode_length(conversation_data)
if episode_length is None:
self.log("Episode length unknown for interactive data; deferring process rewards.",
level='warning')
if episode_length is None or episode_length <= 0:
episode_length = 1
desc = f'[Outer {outer_epoch+1}/{self.config.outer_epochs}, Inner {inner_epoch+1}/{self.config.inner_epochs}] Sessions'
total = episode_length if episode_length > 0 else None
steps_processed = 0
for session_idx, session_text in tqdm(enumerate(sessions), total=total, desc=desc):
step_log = self._process_session(
session_text=session_text,
memory_bank=memory_bank,
session_idx=session_idx,
ppo_buffer=ppo_buffer,
episode_length=episode_length,
session_embedding=session_embeddings[session_idx] if session_embeddings is not None else None
)
episode_log['steps'].append(step_log)
steps_processed += 1
# Evaluate on QA tasks (this is the delayed reward)
# Pass context for case collection
conversation_id = conversation_data.get('sample_id', str(id(conversation_data)))
qa_performance, raw_performance = self._evaluate_qa(
conversation_data, memory_bank,
conversation_id=conversation_id,
outer_epoch=outer_epoch,
inner_epoch=inner_epoch,
step=steps_processed # step = number of sessions processed
)
episode_log['final_qa_performance'] = qa_performance
episode_log['raw_performance'] = raw_performance
episode_log['total_reward'] = qa_performance
# Finish episode in buffer (set final reward)
# Use reward redistribution for long horizon if configured
redistribute = getattr(self.config, 'redistribute_reward', False)
redistribution_decay = getattr(self.config, 'reward_redistribution_decay', 0.95)
final_reward_last_ratio = getattr(self.config, 'final_reward_last_ratio', 0.0)
ppo_buffer.finish_episode(
final_reward=qa_performance,
redistribute=redistribute,
redistribution_decay=redistribution_decay,
final_reward_last_ratio=final_reward_last_ratio
)
return episode_log
def _process_session(self, session_text: str, memory_bank: MemoryBank,
session_idx: int, ppo_buffer: PPOBuffer,
episode_length: int = None,
session_embedding: np.ndarray = None) -> Dict:
"""
Process one session: retrieve memories, select operation, execute
For PPO: stores state, action, log_prob, value in buffer
Args:
session_embedding: Pre-computed session embedding (for batch efficiency).
If None, will compute on-the-fly.
episode_length: Optional episode length for reward shaping. If None,
process rewards are deferred until episode ends.
"""
step_log = {}
# Use pre-computed state encoder embedding if provided, otherwise compute on-the-fly
if session_embedding is None:
session_embedding = self.state_encoder._encode_texts(session_text)
if session_embedding.ndim == 2:
session_embedding = session_embedding[0]
# Retrieve relevant memories using state encoder embeddings (for training)
retrieved_memories, retrieved_indices, retrieved_memory_embeddings = memory_bank.retrieve(
session_embedding, use_state_encoder=True, return_embeddings=True
)
step_log['retrieved_memories'] = retrieved_memories
step_log['retrieved_indices'] = retrieved_indices
# Encode state
state_embedding = self.state_encoder.encode(
session_text,
retrieved_memories,
session_embedding=session_embedding,
memory_embeddings=retrieved_memory_embeddings
)
step_log['state_embedding'] = state_embedding
# Get candidate operations
candidate_ops = self.operation_bank.get_candidate_operations()
step_log['candidate_ops'] = [op.name for op in candidate_ops]
# Get operation embeddings
op_embeddings = np.vstack([op.embedding for op in candidate_ops])
new_op_indices = self.operation_bank.get_new_action_indices(candidate_ops)
if len(new_op_indices) > 0:
new_op_mask = np.zeros(len(candidate_ops), dtype=np.float32)
new_op_mask[new_op_indices] = 1.0
else:
new_op_mask = None
# Controller selects operation(s) (samples from policy)
# Use no_grad during rollout to avoid unnecessary graph construction
state_tensor = torch.tensor(state_embedding, dtype=torch.float32).to(self.device)
op_tensor = torch.tensor(op_embeddings, dtype=torch.float32).to(self.device)
with torch.no_grad():
action_idx, log_prob, value = self.controller(
state_tensor, op_tensor, deterministic=False, new_op_mask=new_op_mask
)
# Handle both single action (K=1) and top-K actions
if isinstance(action_idx, list):
# Top-K case: multiple selected operations
selected_ops = [candidate_ops[idx] for idx in action_idx]
selected_op_names = [op.name for op in selected_ops]
self.log(f"Selected ops (top-K): {selected_op_names}")
step_log['selected_op'] = selected_op_names # List of names for top-K
else:
# Single action case
selected_ops = [candidate_ops[action_idx]]
self.log(f"Selected op: {selected_ops[0].name}")
step_log['selected_op'] = selected_ops[0].name # Single name for backward compatibility
step_log['selected_ops'] = selected_ops # List of Operation objects
step_log['action_idx'] = action_idx
step_log['log_prob'] = log_prob
step_log['value'] = value
# Execute operation(s) - optionally prepend fixed initial operations
executor_ops = selected_ops
# Executor handles the logic for single vs multiple operations internally
exec_results = self.executor.execute_operation(
operation=executor_ops,
session_text=session_text,
retrieved_memories=retrieved_memories
)
step_log['exec_results'] = [str(r) for r in exec_results]
step_log['parse_total'] = len(exec_results)
step_log['parse_fail_count'] = sum(1 for r in exec_results if not r.success)
process_reward_meta = self._build_process_reward_meta(selected_ops, exec_results)
step_len = episode_length if episode_length is not None and episode_length > 0 else 1
process_reward = self._compute_process_reward_from_meta(process_reward_meta, step_len)
step_log['process_reward'] = process_reward
# Immediate reward = process reward
immediate_reward = process_reward
# Store transition in PPO buffer
ppo_buffer.push(
state_emb=state_embedding,
op_embs=op_embeddings,
action=action_idx, # int or List[int]
log_prob=log_prob,
value=value,
reward=immediate_reward,
new_op_mask=new_op_mask
)
# Apply all results to memory bank
operation_names = []
seen = set()
for op in selected_ops:
name = getattr(op, "name", None)
if name and name not in seen:
seen.add(name)
operation_names.append(name)
success = self.executor.apply_to_memory_bank(
results=exec_results,
memory_bank=memory_bank,
retrieved_indices=retrieved_indices,
operation_name=operation_names
)
step_log['apply_success'] = success
# Store for logging
step_log['session_text'] = session_text
step_log['session_idx'] = session_idx
# Update memory bank timestep
memory_bank.step()
return step_log
def _score_qa_responses(self, qa_list: List[Dict], valid_qa_indices: List[int],
ret, reward_metric: str, eval_args):
f1_scores = []
predictions = {}
f1_scores_map = {}
for i, response, _, success in ret:
qa = qa_list[i]
ground_truth = self.evaluator.get_ground_truth(qa)
prediction = response.strip() if success and response is not None else ""
if str(getattr(self.args, "dataset", "")).lower() == "hotpotqa":
extractor = getattr(self.evaluator, "_extract_answer", None)
if callable(extractor):
prediction = extractor(prediction)
f1 = self.evaluator.compute_f1(prediction, ground_truth, qa)
f1_scores.append(f1)
predictions[i] = prediction
f1_scores_map[i] = f1
llm_judge_scores = {}
if reward_metric == 'llm_judge':
judge_task_args = []
for qa_idx in valid_qa_indices:
qa = qa_list[qa_idx]
ground_truth = self.evaluator.get_ground_truth(qa)
prediction = predictions.get(qa_idx, "")
prompt = self.evaluator.build_judge_prompt(
question=qa['question'],
ground_truth=ground_truth,
prediction=prediction,
qa_item=qa
)
judge_task_args.append((qa_idx, prompt, eval_args))
if len(judge_task_args) > 0:
judge_scores = llm_judge(task_args=judge_task_args, args=eval_args)
for idx, (qa_idx, _, _) in enumerate(judge_task_args):
llm_judge_scores[qa_idx] = judge_scores[idx]
if reward_metric == 'llm_judge':
judge_scores_list = [llm_judge_scores.get(idx, 0.0) for idx in valid_qa_indices]
avg_reward = np.mean(judge_scores_list) if len(judge_scores_list) > 0 else 0.0
else:
avg_reward = np.mean(f1_scores) if len(f1_scores) > 0 else 0.0
return avg_reward, predictions, f1_scores_map, llm_judge_scores, f1_scores
def _evaluate_qa(self, conversation_data: Dict, memory_bank: MemoryBank,
conversation_id: str = None, outer_epoch: int = 0,
inner_epoch: int = 0, step: int = 0):
"""
Evaluate QA performance on the conversation.
Uses the evaluator for the configured dataset to handle:
- QA filtering (e.g., skip adversarial questions)
- Prompt building
- Metric computation
Also collects DesignerCase objects if case collection is active.
Args:
conversation_data: Conversation data dict
memory_bank: Memory bank to retrieve from
conversation_id: ID for case tracking
outer_epoch: Current outer epoch for case tracking
inner_epoch: Current inner epoch for case tracking
step: Current step for case tracking
Returns:
Tuple(reward_value, raw_performance)
"""
from llm_utils import get_llm_response
self.log("Evaluating QA...")
eval_args = self.evaluator.prepare_eval_args()
# Get QA list using data processor
qa_list = self.data_processor.get_qa_list(conversation_data)
if len(qa_list) == 0:
if hasattr(self.evaluator, "get_episode_reward"):
reward = float(self.evaluator.get_episode_reward(conversation_data))
return reward, reward
return 0.0, 0.0
# Filter valid QA items using evaluator
valid_qa = self.evaluator.filter_qa_list(qa_list)
if len(valid_qa) == 0:
return 0.0, 0.0
sampled_valid_qa = self.evaluator.sample_train_qa_list(
qa_list=qa_list,
valid_qa=valid_qa,
conversation_id=conversation_id,
outer_epoch=outer_epoch,
inner_epoch=inner_epoch
)
if len(sampled_valid_qa) == 0:
return 0.0, 0.0
if str(getattr(self.args, "dataset", "")).lower() == "locomo":
sampling_ratio = getattr(self.config, "locomo_train_query_sampling_ratio", 1.0)
try:
sampling_ratio = float(sampling_ratio)
except (TypeError, ValueError):
sampling_ratio = 1.0
if sampling_ratio < 1.0:
def _category_counts(items):
counts = {}
for _, qa_item in items:
try:
category = int(qa_item.get('category', 1))
except (TypeError, ValueError):
category = 1
counts[category] = counts.get(category, 0) + 1
return counts
self.log(
"[LoCoMo Train Eval Sampling] "
f"sample_id={conversation_id or 'unknown'} "
f"ratio={sampling_ratio:.4f} "
f"before={len(valid_qa)} after={len(sampled_valid_qa)} "
f"before_categories={_category_counts(valid_qa)} "
f"after_categories={_category_counts(sampled_valid_qa)}"
)
valid_qa = sampled_valid_qa
# Collect questions for batch embedding
valid_qa_indices = [idx for idx, _ in valid_qa]
questions = [qa['question'] for _, qa in valid_qa]
# Batch compute all question embeddings at once
q_embeddings = get_embeddings(
eval_args.retriever,
questions,
'query'
)
# Build task_args for parallel LLM calls
# Also store retrieval info for case collection
task_args = []
retrieval_info = {} # qa_idx -> (retrieved_mems, retrieved_indices)
for idx, (qa_idx, qa) in enumerate(valid_qa):
question = qa['question']
q_embedding = q_embeddings[idx]
# Retrieve from memory bank
retrieved_mems, retrieved_indices = memory_bank.retrieve(
q_embedding, use_state_encoder=False
)
retrieval_info[qa_idx] = (retrieved_mems, list(retrieved_indices))
# Build prompt using evaluator
prompt = self.evaluator.build_prompt(question, retrieved_mems, qa)
task_args.append((qa_idx, prompt, eval_args))
# Call LLM in parallel
if len(task_args) == 0:
return 0.0, 0.0
ret = get_llm_response(args=eval_args, task_args=task_args)
# Compute scores and collect cases (rolling failure pool)
reward_metric = getattr(self.config, 'reward_metric', 'f1').lower()
collect_cases = (self.designer is not None)
f1_threshold = getattr(self.config, 'designer_f1_threshold', 0.5)
need_llm_judge = reward_metric == 'llm_judge'
# Get memory bank snapshot once if collecting (avoid repeated serialization)
memory_snapshot = memory_bank.to_dict() if collect_cases else None
avg_reward, predictions, f1_scores_map, llm_judge_scores, _ = self._score_qa_responses(
qa_list, valid_qa_indices, ret, reward_metric, eval_args
)
if collect_cases:
# Collect cases
for qa_idx in valid_qa_indices:
qa = qa_list[qa_idx]
retrieved_mems, retrieved_indices = retrieval_info.get(qa_idx, ([], []))
f1 = f1_scores_map.get(qa_idx, 0.0)
prediction = predictions.get(qa_idx, "")
judge_score = llm_judge_scores.get(qa_idx, 0.0)
# Get ground truth using evaluator (handles both 'answer' and 'answers' fields)
case_ground_truth = self.evaluator.get_ground_truth(qa)
if isinstance(case_ground_truth, list):
case_ground_truth_str = ', '.join(str(ans) for ans in case_ground_truth)
else:
case_ground_truth_str = str(case_ground_truth)
if need_llm_judge:
is_correct = (judge_score == 1.0)
else:
is_correct = (f1 >= f1_threshold)
case = DesignerCase(
query_id=f"{conversation_id}_{qa_idx}" if conversation_id else str(qa_idx),
question=qa['question'],
ground_truth=case_ground_truth_str,
evidence=qa.get('evidence', None),
category=qa.get('category', None),
memory_bank_snapshot=memory_snapshot,
retrieved_memories=retrieved_mems,
retrieved_indices=retrieved_indices,
prediction=prediction,
is_correct=is_correct,
f1_score=f1,
llm_judge_score=judge_score,
conversation_id=conversation_id,
epoch=outer_epoch * self.config.inner_epochs + inner_epoch,
step=step
)
self.designer.case_collector.add_case(case)
return avg_reward, avg_reward
def update_controller(self, ppo_buffer: PPOBuffer) -> Dict:
"""
Update controller using PPO with minibatch updates
- Compute returns and advantages using GAE
- Multiple epochs of PPO updates with shuffled minibatches
"""
if len(ppo_buffer) == 0:
return {
'policy_loss': 0.0,
'value_loss': 0.0,
'entropy': 0.0,
'topk_entropy': 0.0,
'topk_mass': 0.0,
'topk_bin_entropy': 0.0,
'skipped': True
}
# Compute returns and advantages
returns, advantages = ppo_buffer.compute_returns_and_advantages(
gamma=self.controller.gamma,
gae_lambda=self.controller.gae_lambda,
last_value=0.0 # Episode ended
)
# Normalize advantages ONCE for the full batch (before minibatch splitting)
# This ensures consistent scale across all minibatches
if len(advantages) > 1:
advantages = (advantages - advantages.mean()) / (advantages.std() + 1e-8)
# Get batch data
batch = ppo_buffer.get_batch()
n_samples = len(batch['states'])
# Determine minibatch size (0 means full batch)
minibatch_size = self.minibatch_size if self.minibatch_size > 0 else n_samples
# Multiple PPO update epochs with minibatch
total_loss_info = {'policy_loss': 0.0, 'value_loss': 0.0, 'entropy': 0.0,
'topk_entropy': 0.0, 'topk_mass': 0.0, 'topk_bin_entropy': 0.0,
'approx_kl': 0.0, 'clip_frac': 0.0,
'explained_variance': 0.0, 'value_mean': 0.0,
'return_mean': 0.0, 'advantage_mean': 0.0}
n_updates = 0
early_stop = False
for epoch in range(self.ppo_epochs):
if early_stop:
break
# Shuffle indices at the start of each epoch
indices = np.random.permutation(n_samples)
# Track epoch-level KL for more stable early stopping
epoch_kl_sum = 0.0
epoch_mb_count = 0
# Process minibatches
for start in range(0, n_samples, minibatch_size):
end = min(start + minibatch_size, n_samples)
mb_indices = indices[start:end]
# Extract minibatch
mb_batch = {
'states': [batch['states'][i] for i in mb_indices],
'op_embs': [batch['op_embs'][i] for i in mb_indices],
'new_op_masks': [batch['new_op_masks'][i] for i in mb_indices],
'actions': [batch['actions'][i] for i in mb_indices],
'log_probs': [batch['log_probs'][i] for i in mb_indices],
'values': [batch['values'][i] for i in mb_indices],
}
mb_returns = returns[mb_indices]
mb_advantages = advantages[mb_indices]
# Compute PPO loss on minibatch
loss, loss_info = self.controller.compute_ppo_loss(mb_batch, mb_returns, mb_advantages)
# Update
self.optimizer.zero_grad()
loss.backward()
torch.nn.utils.clip_grad_norm_(self.controller.parameters(), self.max_grad_norm)
self.optimizer.step()
# Accumulate loss info
for key in total_loss_info:
if key in loss_info:
total_loss_info[key] += loss_info[key]
n_updates += 1
# Accumulate epoch-level KL
epoch_kl_sum += loss_info.get('approx_kl', 0.0)
epoch_mb_count += 1
# Early stopping based on epoch-average KL (more stable than per-minibatch)
if self.target_kl is not None and self.target_kl > 0 and epoch_mb_count > 0:
epoch_avg_kl = epoch_kl_sum / epoch_mb_count
if epoch_avg_kl > self.target_kl:
early_stop = True
# Average loss info
n_updates = max(n_updates, 1)
for key in total_loss_info:
total_loss_info[key] /= n_updates
total_loss_info['n_updates'] = n_updates
total_loss_info['skipped'] = False
self.total_steps += 1
return total_loss_info
def train(self, train_data: List[Dict]):
"""
Main training loop with PPO
- Collects episodes (on-policy)
- Computes advantages using GAE
- Multiple PPO update epochs per batch
"""
start_outer_epoch = max(0, int(getattr(self, 'completed_outer_epoch', 0) or 0))
if start_outer_epoch >= self.config.outer_epochs:
self.log(
f"No remaining outer epochs to train: completed_outer_epoch={start_outer_epoch}, "
f"configured outer_epochs={self.config.outer_epochs}.",
level='warning'
)
return
# Initialize wandb
if mp.current_process().name == "MainProcess":
wandb_key = getattr(self.args, 'wandb_key', None)
if wandb_key:
wandb.login(key=wandb_key, relogin=True)
resume_new_wandb_run = bool(getattr(self.args, 'resume_new_wandb_run', False))
wandb_init_kwargs = {
'project': getattr(self.args, 'wandb_project', 'memskill'),
'name': getattr(self.args, 'wandb_run_name', None) or self.resume_wandb_run_name,
'config': {
# PPO hyperparameters
'gamma': self.controller.gamma,
'gae_lambda': self.controller.gae_lambda,
'clip_epsilon': self.controller.clip_epsilon,
'vf_clip': getattr(self.controller, 'vf_clip', 0.0),
'entropy_coef': self.controller.entropy_coef,
'value_coef': self.controller.value_coef,
'ppo_epochs': self.ppo_epochs,
'minibatch_size': self.minibatch_size,
'target_kl': self.target_kl,
'max_grad_norm': self.max_grad_norm,
'batch_size': self.batch_size,
'controller_lr': self.config.controller_lr,
'action_top_k': self.controller.action_top_k, # Top-K action selection
# Architecture
'controller_hidden_dim': self.config.controller_hidden_dim,
'state_dim': self.config.state_dim,
'op_embedding_dim': self.config.op_embedding_dim,
# Training schedule
'outer_epochs': self.config.outer_epochs,
'inner_epochs': self.config.inner_epochs,
'ema_alpha': getattr(self.config, 'ema_alpha', 0.1),
# Other
'dataset': self.args.dataset,
'locomo_train_query_sampling_ratio': getattr(
self.config, 'locomo_train_query_sampling_ratio', 1.0
),
}
}
if self.resume_wandb_run_id and not resume_new_wandb_run:
wandb_init_kwargs['id'] = self.resume_wandb_run_id
wandb_init_kwargs['resume'] = 'must'
self.log(f"Resuming wandb run: {self.resume_wandb_run_id}")
elif self.resume_from_checkpoint and resume_new_wandb_run:
self.log("Resuming training from checkpoint with a fresh wandb run.")
elif self.resume_from_checkpoint:
self.log("Checkpoint has no wandb_run_id; starting a new wandb run.", level='warning')
wandb.init(**wandb_init_kwargs)
run = getattr(wandb, 'run', None)
if run is not None:
self.resume_wandb_run_id = getattr(run, 'id', None)
self.resume_wandb_run_name = getattr(run, 'name', None)
self.log("=" * 80)
self.log("Starting Agentic Memory Training (PPO)")
self.log("=" * 80)
self._prewarm_retriever_models()
if self.resume_from_checkpoint:
self.log(
f"Resuming training from outer epoch {start_outer_epoch + 1}/"
f"{self.config.outer_epochs}."
)
for outer_epoch in range(start_outer_epoch, self.config.outer_epochs):
self.log(f"\n{'='*80}")
self.log(f"Outer Epoch {outer_epoch + 1}/{self.config.outer_epochs}")
self.log(f"{'='*80}")
# Inner loop: train controller with fixed op bank
inner_logs = []
outer_epoch_last_step = self.wandb_step_cursor if self.wandb_step_cursor is not None else -1
for inner_epoch in range(self.config.inner_epochs):
# Create fresh PPO buffer for collecting episodes
ppo_buffer = PPOBuffer()
# Collect multiple episodes (batch)
batch_rewards = []
batch_raw_rewards = []
batch_steps = []
bias_scale = 0.0
bias_steps = getattr(self.config, 'new_action_bias_steps', 0)
if self.new_action_bias_active and bias_steps > 0:
bias_scale = max(0.0, 1.0 - (self.new_action_bias_step / bias_steps))
self.controller.set_new_action_bias_scale(bias_scale)
# Parallel episode collection using ThreadPoolExecutor
max_workers = self._get_episode_workers()
with ThreadPoolExecutor(max_workers=max_workers) as executor:
futures = [
executor.submit(
self._run_single_episode,
train_data, outer_epoch, inner_epoch
)
for _ in range(self.batch_size)
]
for future in as_completed(futures):
result = future.result()
episode_log = result['episode_log']
local_buffer = result['local_buffer']
op_stats = result['op_stats']
# Merge local buffer into main buffer
ppo_buffer.merge(local_buffer)
batch_rewards.append(episode_log['total_reward'])
batch_raw_rewards.append(
episode_log.get('raw_performance', episode_log['total_reward'])
)
batch_steps.extend(episode_log['steps'])
# Update operation statistics (in main thread)
for stat in op_stats:
op = self.operation_bank.get_operation(stat['op_name'])
op.update_stats(stat['reward'])
# Update EMA based on batch-level usage (after all episodes collected)
# Handle both single op (string) and top-K ops (list of strings)
op_usage_counts = {}
for step in batch_steps:
selected_op = step.get('selected_op', 'unknown')
if isinstance(selected_op, list):
for op_name in selected_op:
op_usage_counts[op_name] = op_usage_counts.get(op_name, 0) + 1
else:
op_usage_counts[selected_op] = op_usage_counts.get(selected_op, 0) + 1
total_steps = len(batch_steps)
ema_alpha = getattr(self.config, 'ema_alpha', 0.1)
self.operation_bank.batch_update_ema(op_usage_counts, total_steps, ema_alpha)
# PPO update on collected episodes
update_info = self.update_controller(ppo_buffer)
# Log
avg_reward = np.mean(batch_rewards)
avg_raw_performance = (
np.mean(batch_raw_rewards) if len(batch_raw_rewards) > 0 else 0.0
)
inner_logs.append({
'inner_epoch': inner_epoch,
'reward': avg_reward,
'raw_performance': avg_raw_performance,
'steps': batch_steps,
**update_info
})
if self.new_action_bias_active and bias_steps > 0:
self.new_action_bias_step += 1
if self.new_action_bias_step >= bias_steps:
self.new_action_bias_active = False
self.controller.set_new_action_bias_scale(0.0)
self.operation_bank.set_new_operation_names([])
# Wandb logging for PPO metrics
global_step = self.wandb_step_cursor + 1
# Compute process reward stats
process_rewards = [s.get('process_reward', 0.0) for s in batch_steps]
match_rate = sum(1 for p in process_rewards if p == 0.0) / max(len(process_rewards), 1)
# Compute operation usage statistics
# Handle both single op (string) and top-K ops (list of strings)
op_counts = {}
for step in batch_steps:
selected_op = step.get('selected_op', 'unknown')
if isinstance(selected_op, list):
for op_name in selected_op:
op_counts[op_name] = op_counts.get(op_name, 0) + 1
else:
op_counts[selected_op] = op_counts.get(selected_op, 0) + 1
num_episodes = max(len(batch_rewards), 1)
# New-operation exploration stats
# Handle both single op (string) and top-K ops (list of strings)
new_op_names = set(self.operation_bank.new_operation_names)
new_op_selected = 0
for step in batch_steps:
selected_op = step.get('selected_op')
if isinstance(selected_op, list):
new_op_selected += sum(1 for op in selected_op if op in new_op_names)
elif selected_op in new_op_names:
new_op_selected += 1
new_op_selected_rate = new_op_selected / max(len(batch_steps), 1)
parse_fail_count = sum(step.get('parse_fail_count', 0) for step in batch_steps)
parse_total = sum(step.get('parse_total', 0) for step in batch_steps)
parse_fail_rate = parse_fail_count / max(parse_total, 1)
wandb_log = {
# Training metrics
'train/reward': avg_reward,
'train/raw_performance': avg_raw_performance,
'train/reward_std': np.std(batch_rewards) if len(batch_rewards) > 1 else 0.0,
'train/reward_min': np.min(batch_rewards) if len(batch_rewards) > 0 else 0.0,
'train/reward_max': np.max(batch_rewards) if len(batch_rewards) > 0 else 0.0,
'train/episode_length': len(batch_steps) / num_episodes,
# Process reward (op selection quality)
'train/process_reward_mean': np.mean(process_rewards) if process_rewards else 0.0,
# PPO losses
'ppo/policy_loss': update_info.get('policy_loss', 0.0),
'ppo/value_loss': update_info.get('value_loss', 0.0),
'ppo/entropy': update_info.get('entropy', 0.0),
'ppo/topk_entropy': update_info.get('topk_entropy', 0.0),
'ppo/topk_mass': update_info.get('topk_mass', 0.0),
'ppo/topk_bin_entropy': update_info.get('topk_bin_entropy', 0.0),
'ppo/approx_kl': update_info.get('approx_kl', 0.0),
'ppo/clip_frac': update_info.get('clip_frac', 0.0),
'ppo/n_updates': update_info.get('n_updates', 0),
# Value function diagnostics
'ppo/explained_variance': update_info.get('explained_variance', 0.0),
'ppo/value_mean': update_info.get('value_mean', 0.0),
'ppo/return_mean': update_info.get('return_mean', 0.0),
'ppo/advantage_mean': update_info.get('advantage_mean', 0.0),
# Training state
'train/total_steps': self.total_steps,
'train/outer_epoch': outer_epoch,
'train/inner_epoch': inner_epoch,
'train/global_step': global_step,
'train/parse_fail_count': parse_fail_count,
'train/parse_fail_rate': parse_fail_rate,
# Operation statistics
'operation/num_operations': len(self.operation_bank.operations),
'operation/match_rate': match_rate,
# New op exploration
'explore/new_op_count': len(new_op_names),
'explore/new_op_selected_count': new_op_selected,
'explore/new_op_selected_rate': new_op_selected_rate,
'explore/new_action_bias_scale': bias_scale,
'explore/new_action_bias_active': float(self.new_action_bias_active),
'explore/new_action_bias_step': self.new_action_bias_step,
'explore/new_action_p_min': getattr(self.config, 'new_action_p_min', 0.0),
'explore/new_action_delta_max': getattr(self.config, 'new_action_delta_max', 0.0),
}
# Add per-operation average call counts
for op_name, count in op_counts.items():
avg_calls = count / num_episodes
wandb_log[f'operation/{op_name}_avg'] = avg_calls
self._wandb_log(wandb_log, step=global_step)
self.wandb_step_cursor = global_step
outer_epoch_last_step = global_step
# Track reward for stage average calculation
self.stage_rewards.append(avg_reward)
if (inner_epoch + 1) % 1 == 0:
recent_logs = inner_logs[-10:]
avg_reward = np.mean([log['reward'] for log in recent_logs])
avg_policy_loss = np.mean([log.get('policy_loss', 0) for log in recent_logs])
avg_value_loss = np.mean([log.get('value_loss', 0) for log in recent_logs])
avg_entropy = np.mean([log.get('entropy', 0) for log in recent_logs])
self.log(f" Inner Epoch {inner_epoch + 1}/{self.config.inner_epochs}: "
f"Reward={avg_reward:.4f}, PolicyLoss={avg_policy_loss:.4f}, "
f"ValueLoss={avg_value_loss:.4f}, Entropy={avg_entropy:.4f}")
# Outer loop: evolve operation bank
if self.designer is not None and (outer_epoch + 1) % self.config.designer_freq == 0:
self.log(f"\n{'='*80}")
self.log("Evolving Operation Bank...")
self.log(f"{'='*80}")
# =====================================================================
# Step 1: Calculate stage average reward (using last 1/4 of rewards)
# =====================================================================
stage_reward_fraction = getattr(self.config, 'stage_reward_fraction', 0.25)
if len(self.stage_rewards) > 0:
# Use last fraction of stage rewards for more stable estimate
n_rewards = len(self.stage_rewards)
start_idx = int(n_rewards * (1.0 - stage_reward_fraction))
stable_rewards = self.stage_rewards[start_idx:]
use_moving_avg = bool(getattr(self.config, 'stage_reward_use_moving_avg', False))
if use_moving_avg and len(stable_rewards) > 0:
window = int(getattr(self.config, 'stage_reward_window', 5) or 1)
window = max(1, window)
rewards_arr = np.array(stable_rewards, dtype=np.float32)
window = min(window, len(rewards_arr))
if window == 1:
stage_avg_reward = float(np.mean(rewards_arr))
else:
cumsum = np.cumsum(rewards_arr, dtype=np.float64)
cumsum = np.concatenate(([0.0], cumsum))
moving_avg = (cumsum[window:] - cumsum[:-window]) / window
stage_avg_reward = float(np.mean(moving_avg)) if len(moving_avg) > 0 else 0.0
self.log(
f"Stage average reward (last {stage_reward_fraction*100:.0f}%, "
f"moving avg window={window}): {stage_avg_reward:.4f} "
f"(from {len(stable_rewards)} samples)"
)
else:
stage_avg_reward = np.mean(stable_rewards) if len(stable_rewards) > 0 else 0.0
self.log(
f"Stage average reward (last {stage_reward_fraction*100:.0f}%): "
f"{stage_avg_reward:.4f} (from {len(stable_rewards)} samples)"
)
else:
stage_avg_reward = 0.0
self.log("No stage rewards collected")
# =====================================================================
# Step 2: Add current snapshot to manager
# =====================================================================
# The pending_evolution_result (set after last evolve) will be consumed here
is_new_best = self.snapshot_manager.add_snapshot(
operation_bank=self.operation_bank,
avg_reward=stage_avg_reward
)
# Clear stage rewards for next stage
self.stage_rewards = []
# =====================================================================
# Step 3: Check early stopping conditions
# =====================================================================
max_evolves = getattr(self.config, 'max_designer_evolves', 6)
patience = getattr(self.config, 'designer_early_stop_patience', 3)
if self.snapshot_manager.should_stop_evolving(max_evolves, patience):
self.log(f"\n{'='*80}")
self.log("STOPPING TRAINING: Evolution early stop triggered")
self.log(f"Total evolves: {self.snapshot_manager.total_evolves}, "
f"Consecutive no improvement: {self.snapshot_manager.consecutive_no_improvement}")
self.log(f"{'='*80}")
# Log early stop to wandb
self._wandb_log({
'evolution/early_stop': 1,
'evolution/total_evolves': self.snapshot_manager.total_evolves,
'evolution/best_reward': self.snapshot_manager.get_best_snapshot().avg_reward if self.snapshot_manager.get_best_snapshot() else 0.0,
}, step=outer_epoch_last_step)
self.training_logs.extend(inner_logs)
self.completed_outer_epoch = outer_epoch + 1
# Break out of outer loop
break
# =====================================================================
# Step 4: Rollback to best snapshot if current is not best
# =====================================================================
best_snapshot = self.snapshot_manager.get_best_snapshot()
if not is_new_best and best_snapshot is not None:
self.log(f"Rolling back to best snapshot (stage {best_snapshot.stage_id}, "
f"reward={best_snapshot.avg_reward:.4f})")
# Restore operation bank from best snapshot
self.operation_bank = OperationBank.from_dict(
best_snapshot.operation_bank_dict,
encoder=self.op_encoder
)
# =====================================================================
# Step 5: Generate feedback for prompts
# =====================================================================
# Simple feedback for analysis prompt (focuses on failure cases)
evolution_feedback = self.snapshot_manager.format_feedback_for_prompt(detailed=True)
# Detailed feedback for refinement prompt (includes before/after comparison)
evolution_feedback_detailed = self.snapshot_manager.format_evolution_feedback_for_refinement()
if evolution_feedback:
self.log(f"Evolution feedback (for analysis):\n{evolution_feedback}")
if evolution_feedback_detailed:
self.log(f"Evolution feedback (for refinement):\n{evolution_feedback_detailed}")
# =====================================================================
# Step 6: Log failure pool stats
# =====================================================================
num_cases = 0
num_failures = 0
if self.designer is not None:
num_cases = len(self.designer.case_collector.get_all_cases())
num_failures = num_cases
self.log(f"Failure pool size: {num_cases} cases")
# =====================================================================
# Step 7: Two-stage designer evolution with retry logic
# =====================================================================
max_retries = getattr(self.config, 'op_evolution_trials', 3)
evolution_applied = False
evolution_result = None
# Determine whether to use saved analysis cases from best snapshot
# or prepare fresh cases from current stage's collection.
# If current is NOT best (rolled back to best), use best's saved cases.
use_saved_cases = (not is_new_best and best_snapshot is not None
and best_snapshot.analysis_cases is not None
and len(best_snapshot.analysis_cases) > 0)
if use_saved_cases:
# Use best snapshot's saved analysis cases
self.log(f"Using saved analysis cases from best snapshot (stage {best_snapshot.stage_id})")
analysis_prompt = self.designer.build_analysis_prompt_from_saved_cases(
saved_cases=best_snapshot.analysis_cases,
operation_bank=self.operation_bank,
evolution_feedback=evolution_feedback
)
prepared_data = {
'analysis_prompt': analysis_prompt,
'analysis_cases': best_snapshot.analysis_cases, # Already serialized
'evolution_feedback': evolution_feedback
}
else:
# Prepare fresh evolution (expensive: embedding, clustering)
prepared_data = self.designer.prepare_evolution(
self.operation_bank, evolution_feedback=evolution_feedback
)
# Save analysis_cases to current snapshot (for future use if this becomes best)
if prepared_data is not None and 'analysis_cases' in prepared_data:
# Serialize DesignerCase objects to dicts for storage
serialized_cases = [case.to_dict() for case in prepared_data['analysis_cases']]
self.snapshot_manager.set_latest_snapshot_analysis_cases(serialized_cases)
self.log(f"Saved {len(serialized_cases)} analysis cases to current snapshot")
if prepared_data is None:
self.log("No cases to analyze, skipping evolution")
evolution_result = {'action': 'no_change', 'reasoning': 'No cases to analyze'}
else:
# Retry the LLM calls up to max_retries times
for attempt in range(1, max_retries + 1):
self.log(f"Designer evolution attempt {attempt}/{max_retries}")
evolution_result = self.designer.run_evolution(
operation_bank=self.operation_bank,
prepared_data=prepared_data,
evolution_feedback_for_refinement=evolution_feedback_detailed
)
evolution_applied = self.designer.apply_evolution(self.operation_bank, evolution_result)
if evolution_applied:
self.log(f"Evolution succeeded on attempt {attempt}")
break
else:
self.log(f"Evolution attempt {attempt} returned no changes: {evolution_result.get('reasoning', 'N/A')}")
if attempt < max_retries:
self.log(f"Retrying evolution...")
# Reset collection state but keep rolling failure pool
self.designer.case_collector.clear(reset_pool=False)
# =====================================================================
# Step 8: Store evolution result for next snapshot and increment counter
# =====================================================================
# The evolution_result will be associated with the NEXT snapshot
# (because this evolution will affect the next stage's training)
self.snapshot_manager.set_pending_evolution_result(evolution_result)
self.snapshot_manager.increment_evolve_count()
# Activate new action bias if changes were applied
if evolution_applied:
self.new_action_bias_active = True
self.new_action_bias_step = 0
self.log(f"Evolution applied: {evolution_result.get('action', 'unknown')}")
else:
reason = evolution_result.get('reasoning', 'N/A') if evolution_result else 'No cases to analyze'
self.log(f"No evolution applied after {max_retries} attempts: {reason}")
# Log operation bank evolution to wandb
action_map = {'add_new': 1, 'refine_existing': 2, 'no_change': 0, 'multi': 3}
best_snap = self.snapshot_manager.get_best_snapshot()
num_changes = 0
if evolution_result:
changes = evolution_result.get('changes')
if isinstance(changes, list):
num_changes = len(changes)
self._wandb_log({
'evolution/num_operations': len(self.operation_bank.operations),
'evolution/outer_epoch': outer_epoch,
'evolution/collected_cases': num_cases,
'evolution/failure_cases': num_failures,
'evolution/action': action_map.get(evolution_result.get('action', 'no_change'), 0),
'evolution/num_changes': num_changes,
'evolution/applied': 1 if evolution_applied else 0,
# Snapshot management metrics
'evolution/stage_avg_reward': stage_avg_reward,
'evolution/best_reward': best_snap.avg_reward if best_snap else 0.0,
'evolution/is_new_best': 1 if is_new_best else 0,
'evolution/total_evolves': self.snapshot_manager.total_evolves,
'evolution/consecutive_no_improvement': self.snapshot_manager.consecutive_no_improvement,
'evolution/num_snapshots': len(self.snapshot_manager.snapshots),
'evolution/failed_attempts_accumulated': len(self.snapshot_manager.failed_evolution_attempts),
'evolution/used_saved_cases': 1 if use_saved_cases else 0,
}, step=outer_epoch_last_step)
# Store logs
self.training_logs.extend(inner_logs)
self.completed_outer_epoch = outer_epoch + 1
# Save checkpoint
if (outer_epoch + 1) % 1 == 0:
self.save_checkpoint(outer_epoch + 1)
# Log outer epoch summary to wandb
outer_epoch_reward = np.mean([log['reward'] for log in inner_logs])
self._wandb_log({
'epoch/outer_epoch': outer_epoch,
'epoch/avg_reward': outer_epoch_reward,
}, step=outer_epoch_last_step)
# Final summary
self.resume_from_checkpoint = False
if len(self.training_logs) > 0:
final_avg_reward = np.mean([log['reward'] for log in self.training_logs[-self.config.inner_epochs:]])
else:
final_avg_reward = 0.0
self._wandb_log({
'final/avg_reward': final_avg_reward,
'final/total_steps': self.total_steps,
'final/num_operations': len(self.operation_bank.operations),
}, step=self.wandb_step_cursor)
# Finish wandb run
wandb.finish()
self.log("\n" + "=" * 80)
self.log("Training Completed!")
self.log("=" * 80)
def _compute_process_reward(self, selected_ops, exec_results: List, episode_length: int = 1) -> float:
"""
Compute process reward using budget-based allocation.
Budget design ensures total process reward contribution is bounded:
- process_budget: episode-level budget for match/mismatch (+/- quota per step)
- failure_budget: episode-level budget for LLM failures
- noop_match_scale: reduce NOOP match reward to discourage "always NOOP" hacking
- shaping_scale: global scaling factor for all process rewards
Args:
selected_ops: Selected Operation object or list of Operation objects
exec_results: List of ExecutionResult from LLM
episode_length: Number of steps in the episode (for scaling)
Returns:
Process reward (positive for match, negative for mismatch/failure)
"""
meta = self._build_process_reward_meta(selected_ops, exec_results)
return self._compute_process_reward_from_meta(meta, episode_length)
def _build_process_reward_meta(self, selected_ops, exec_results: List) -> Dict[str, object]:
if selected_ops is None:
selected_ops = []
elif not isinstance(selected_ops, (list, tuple)):
selected_ops = [selected_ops]
selected_types = {op.update_type.lower() for op in selected_ops if op is not None}
successful_results = [r for r in exec_results if r.success]
actual_types = set(r.action_type.lower() for r in successful_results)
return {
'selected_types': sorted(selected_types),
'actual_types': sorted(actual_types),
'exec_total': len(exec_results),
'exec_success': len(successful_results)
}
def _compute_process_reward_from_meta(self, meta: Dict[str, object], episode_length: int) -> float:
# Budget parameters (episode-level)
process_budget = getattr(self.config, 'process_budget', 0.10)
failure_budget = getattr(self.config, 'failure_budget', 0.05)
noop_match_scale = getattr(self.config, 'noop_match_scale', 0.2)
shaping_scale = getattr(self.config, 'shaping_scale', 1.0)
L = max(int(episode_length), 1)
quota = process_budget / L # +/- quota per step
failure_quota = failure_budget / L # failure penalty per step
selected_types = set(meta.get('selected_types', []))
actual_types = set(meta.get('actual_types', []))
exec_total = int(meta.get('exec_total', 0) or 0)
exec_success = int(meta.get('exec_success', 0) or 0)
# Case 1: All results failed (LLM parsing/API failure)
if exec_total > 0 and exec_success == 0:
return -shaping_scale * failure_quota
# Case 2: No results at all (edge case, treat as neutral)
if exec_total == 0:
return 0.0
# Check match against selected ops (set-level)
if selected_types == actual_types:
if selected_types == {'noop'}:
return shaping_scale * (noop_match_scale * quota)
return shaping_scale * quota
intersection_types = selected_types.intersection(actual_types)
intersection_count = len(intersection_types)
if intersection_count > 0:
union_count = len(selected_types.union(actual_types))
if union_count > 0:
overlap_reward = shaping_scale * quota * (intersection_count / union_count)
if intersection_types == {'noop'}:
return noop_match_scale * overlap_reward
return overlap_reward
return 0.0
return -shaping_scale * quota
def _run_single_episode(self, train_data: List[Dict], outer_epoch: int,
inner_epoch: int) -> Dict:
"""
Run a single episode for parallel batch collection.
Each episode uses its own PPOBuffer and MemoryBank.
Args:
train_data: list of conversation data
outer_epoch: current outer epoch index
inner_epoch: current inner epoch index
Returns:
dict with 'episode_log', 'local_buffer', 'op_stats'
"""
# Sample a conversation
conv_idx = np.random.randint(len(train_data))
conversation = self._prepare_conversation_for_episode(train_data[conv_idx])
sessions, episode_length, precompute = self._prepare_sessions(conversation)
# Initialize empty memory bank (independent per episode)
memory_bank = self._initialize_memory_bank()
# Create local PPO buffer for this episode
local_buffer = PPOBuffer()
# Train episode
episode_log = self.train_episode(
conversation, memory_bank, sessions, local_buffer,
outer_epoch=outer_epoch, inner_epoch=inner_epoch,
episode_length=episode_length, precompute_embeddings=precompute
)
# Collect operation stats to update later (thread-safe)
# Handle both single op (string) and top-K ops (list of strings)
op_stats = []
for step in episode_log['steps']:
selected_op = step['selected_op']
if isinstance(selected_op, list):
# Top-K case: record stats for each selected operation
for op_name in selected_op:
op_stats.append({
'op_name': op_name,
'reward': episode_log['total_reward']
})
else:
# Single action case
op_stats.append({
'op_name': selected_op,
'reward': episode_log['total_reward']
})
return {
'episode_log': episode_log,
'local_buffer': local_buffer,
'op_stats': op_stats
}
def _initialize_memory_bank(self, top_k: Optional[int] = None) -> MemoryBank:
"""
Initialize an EMPTY memory bank with state encoder for dual embeddings
Returns:
MemoryBank: empty memory bank
"""
if top_k is None:
top_k = self.config.mem_top_k
memory_bank = MemoryBank(
retriever_name=self.args.retriever,
top_k=top_k,
state_encoder=self.memory_bank_encoder
)
return memory_bank
def _prepare_sessions(self, conversation: Dict):
"""
Prepare session iterator with optional precompute support.
Returns:
sessions: list or iterator of chunks
episode_length: int or None
precompute_embeddings: bool
"""
if self.is_interactive():
sessions = self.data_processor.iter_chunks(conversation)
episode_length = self.data_processor.get_episode_length(conversation)
return sessions, episode_length, False
sessions = self.data_processor.extract_chunks(conversation)
return sessions, len(sessions), True
def _extract_sessions(self, conversation: Dict) -> List[str]:
"""
Extract session/chunk texts from conversation data (non-interactive only).
This method is kept for backward compatibility; new code should use
_prepare_sessions() to handle interactive datasets.
"""
return self.data_processor.extract_chunks(conversation)
def save_checkpoint(self, epoch: int):
"""Save model checkpoint (PPO version)"""
os.makedirs(self.args.save_dir, exist_ok=True)
checkpoint = {
'checkpoint_version': CHECKPOINT_VERSION,
'epoch': epoch,
'completed_outer_epoch': int(getattr(self, 'completed_outer_epoch', 0) or 0),
'controller_state_dict': self.controller.state_dict(),
'optimizer_state_dict': self.optimizer.state_dict(),
'operation_bank': self.operation_bank.to_dict(),
'operation_bank_new_operation_names': sorted(self.operation_bank.new_operation_names),
'total_steps': self.total_steps,
'new_action_bias_active': bool(self.new_action_bias_active),
'new_action_bias_step': int(self.new_action_bias_step),
'wandb_step_cursor': self.wandb_step_cursor if self.wandb_step_cursor is not None else -1,
# Reproducibility / resume
'args': self._get_args_snapshot(),
'config': vars(self.config),
'rng_state': self._get_rng_state(),
# Snapshot manager state
'snapshot_manager': self.snapshot_manager.to_dict() if self.snapshot_manager else None,
'designer_state': self._get_designer_state(),
'stage_rewards': self.stage_rewards,
'training_logs': self.training_logs,
}
run = getattr(wandb, 'run', None)
if run is not None:
checkpoint['wandb_run_id'] = getattr(run, 'id', None)
checkpoint['wandb_run_name'] = getattr(run, 'name', None)
elif self.resume_wandb_run_id is not None:
checkpoint['wandb_run_id'] = self.resume_wandb_run_id
checkpoint['wandb_run_name'] = self.resume_wandb_run_name
# Build filename with wandb run name if available
run_name = getattr(self.args, 'wandb_run_name', None) or 'default'
# Sanitize run name for filename (replace invalid chars)
run_name = run_name.replace('/', '_').replace('\\', '_').replace(':', '_')
path = os.path.join(self.args.save_dir, f'{run_name}_epoch_{epoch}.pt')
torch.save(checkpoint, path)
self.log(f"Saved checkpoint to {path}")
def load_checkpoint(self, path: str):
"""Load model checkpoint (PPO version)"""
try:
checkpoint = torch.load(path, map_location=self.device, weights_only=False)
except TypeError:
checkpoint = torch.load(path, map_location=self.device)
self._log_resume_parameter_differences(checkpoint)
self.controller.load_state_dict(checkpoint['controller_state_dict'])
self.optimizer.load_state_dict(checkpoint['optimizer_state_dict'])
# Load operation bank (controlled by config)
if not getattr(self.config, 'skip_load_operation_bank', False):
self.operation_bank = OperationBank.from_dict(
checkpoint['operation_bank'],
encoder=self.op_encoder
)
self.operation_bank.skip_noop = getattr(self.config, 'skip_noop', False)
self.operation_bank.set_new_operation_names(
checkpoint.get('operation_bank_new_operation_names', [])
)
else:
self.log("Skipping operation bank loading (skip_load_operation_bank=True)")
self.operation_bank.set_new_operation_names([])
self.total_steps = checkpoint.get('total_steps', 0)
self.completed_outer_epoch = self._coerce_completed_outer_epoch(checkpoint)
self.new_action_bias_active = bool(checkpoint.get('new_action_bias_active', False))
self.new_action_bias_step = int(checkpoint.get('new_action_bias_step', 0) or 0)
self.wandb_step_cursor = self._coerce_wandb_step_cursor(checkpoint)
rng_state = checkpoint.get('rng_state', None)
if rng_state is not None:
self._set_rng_state(rng_state)
# Restore snapshot manager state (controlled by config)
if not getattr(self.config, 'skip_load_snapshot_manager', False):
snapshot_manager_data = checkpoint.get('snapshot_manager', None)
if snapshot_manager_data is not None and self.snapshot_manager is not None:
self.snapshot_manager = EvolutionSnapshotManager.from_dict(
snapshot_manager_data, logger=self.logger
)
else:
self.log("Skipping snapshot manager loading (skip_load_snapshot_manager=True)")
# Restore stage rewards
self.stage_rewards = checkpoint.get('stage_rewards', [])
self.training_logs = checkpoint.get('training_logs', []) or []
self._restore_designer_state(checkpoint)
self.resume_from_checkpoint = True
self.resume_wandb_run_id = checkpoint.get('wandb_run_id')
self.resume_wandb_run_name = checkpoint.get('wandb_run_name')
designer_case_count = (
len(self.designer.case_collector.get_all_cases())
if self.designer is not None else 0
)
self.log(
f"Checkpoint resume state: completed_outer_epoch={self.completed_outer_epoch}, "
f"new_action_bias_active={self.new_action_bias_active}, "
f"new_action_bias_step={self.new_action_bias_step}, "
f"wandb_step_cursor={self.wandb_step_cursor}, "
f"designer_cases={designer_case_count}"
)
self.log(f"Loaded checkpoint from {path}")
class OfflineTrainer(BaseTrainer):
"""Trainer for offline datasets with full-session/chunk access."""
def is_interactive(self) -> bool:
return False
class _NoOpProcessor(DataProcessor):
"""Minimal processor placeholder for trainers that don't consume processor output."""
def extract_chunks(self, data: Dict) -> List[str]:
return []
def get_sample_id(self, data: Dict) -> str:
return str(data.get("sample_id") if isinstance(data, dict) else id(data))
def get_qa_list(self, data: Dict) -> List[Dict[str, Any]]:
return []
class AlfworldPairTrainer(BaseTrainer):
"""Trainer for ALFWorld offline pair sampling (A=memory build, B=interactive eval)."""
def __init__(self, args, config):
super().__init__(args, config)
data_path = getattr(config, "alfworld_offline_data", None) or getattr(args, "data_file", None)
if not data_path:
raise ValueError("ALFWorld offline data path is required.")
self.offline_dataset = ALFWorldOfflineDataset.load(data_path)
self._eval_pool = None
self._eval_pool_lock = threading.Lock()
# Replace QA designer with interactive designer if enabled.
if args.enable_designer:
from src.interactive_designer import InteractiveDesigner
self.designer = InteractiveDesigner(
args,
collect_epochs_before_designer=getattr(config, 'collect_epochs_before_designer', 5),
failure_window_epochs=getattr(config, 'designer_failure_window_epochs', 200),
failure_pool_size=getattr(config, 'designer_failure_pool_size', 1000),
num_clusters=getattr(config, 'designer_num_clusters', 5),
samples_per_cluster=getattr(config, 'designer_samples_per_cluster', 3),
f1_threshold=getattr(config, 'designer_f1_threshold', 0.5),
encoder=self.state_encoder._base_encoder,
logger=self.logger
)
def is_interactive(self) -> bool:
return True
def supports_parallel_env(self) -> bool:
# Avoid parallel episodes; batch-B runs its own parallel envs if enabled.
return False
def _get_episode_workers(self) -> int:
return self.batch_size
def _build_data_processor(self):
return _NoOpProcessor()
def _get_eval_pool(self) -> ProcessPoolExecutor:
if self._eval_pool is None:
with self._eval_pool_lock:
if self._eval_pool is None:
workers = int(getattr(self.config, "alfworld_pair_b_workers", 0) or 0)
if workers <= 0:
workers = max(1, self.batch_size)
ctx = mp.get_context("spawn")
self._eval_pool = ProcessPoolExecutor(max_workers=workers, mp_context=ctx)
return self._eval_pool
def _shutdown_eval_pool(self):
if self._eval_pool is not None:
self._eval_pool.shutdown(wait=True)
self._eval_pool = None
def train(self, train_data: List[Dict]):
try:
super().train(train_data)
finally:
self._shutdown_eval_pool()
def _sample_pair(self) -> Tuple[List[Tuple[str, str, Dict]], List[Tuple[str, str, Dict]]]:
batch_a_min = int(getattr(self.config, "alfworld_pair_a_min", 100))
batch_a_max = int(getattr(self.config, "alfworld_pair_a_max", 200))
batch_b_size = int(getattr(self.config, "alfworld_pair_b_size", 0) or 0)
if batch_b_size <= 0:
batch_b_size = self.batch_size
same_type_prob = float(getattr(self.config, "alfworld_pair_same_type_prob", 0.8))
return self.offline_dataset.sample_pair(
batch_a_min=batch_a_min,
batch_a_max=batch_a_max,
batch_b_size=batch_b_size,
same_type_prob=same_type_prob
)
def _build_memory_from_batch_a(self, batch_a: List[Tuple[str, str, Dict]],
memory_bank: MemoryBank,
ppo_buffer: PPOBuffer,
outer_epoch: int,
inner_epoch: int) -> List[Dict]:
trajectories = []
for _, _, entry in batch_a:
if isinstance(entry, dict):
traj = entry.get("trajectory") or ""
if isinstance(traj, str) and traj.strip():
trajectories.append(traj.strip())
chunk_size = getattr(self.config, "alfworld_pair_chunk_size", None)
if chunk_size is None:
chunk_size = getattr(self.config, "chunk_size", None)
chunks = chunk_trajectories_by_tokens(trajectories, chunk_size)
if not chunks:
return []
episode_length = len(chunks)
session_embeddings = self.state_encoder._encode_texts(chunks)
if hasattr(session_embeddings, "ndim") and session_embeddings.ndim == 1:
session_embeddings = session_embeddings.reshape(1, -1)
step_logs = []
for session_idx, session_text in tqdm(
enumerate(chunks),
total=len(chunks),
desc="ALFWorld batch A",
):
step_log = self._process_session(
session_text=session_text,
memory_bank=memory_bank,
session_idx=session_idx,
ppo_buffer=ppo_buffer,
episode_length=episode_length,
session_embedding=session_embeddings[session_idx] if session_embeddings is not None else None
)
step_logs.append(step_log)
return step_logs
def _run_batch_b(self, batch_b: List[Tuple[str, str, Dict]],
memory_bank: MemoryBank) -> List[Dict]:
if not batch_b:
return []
from src.alfworld_env_runner import run_alfworld_episode
objectives = []
query_texts = []
expert_plans = []
query_source = str(getattr(self.config, "alfworld_eval_query_source", "first_observation")
or "first_observation").lower()
if query_source not in ("objective", "first_observation"):
query_source = "first_observation"
for _, _, entry in batch_b:
objective = ""
first_obs = ""
expert_plan = []
if isinstance(entry, dict):
objective = entry.get("objective")
if not isinstance(objective, str):
objective = ""
if not objective:
first_obs = entry.get("first_observation") or ""
if isinstance(first_obs, str) and "Your task is to:" in first_obs:
match = re.search(r"Your task is to:\s*(.+)", first_obs, re.IGNORECASE)
if match:
objective = match.group(1).strip().rstrip(".")
if not first_obs:
first_obs = entry.get("first_observation") or ""
steps = entry.get("steps")
if isinstance(steps, list) and steps:
first_step = steps[0] if isinstance(steps[0], dict) else {}
raw_plan = first_step.get("expert_plan") if isinstance(first_step, dict) else None
if isinstance(raw_plan, list):
if len(raw_plan) == 1 and isinstance(raw_plan[0], str):
candidate = raw_plan[0].strip()
if candidate.startswith("[") and candidate.endswith("]"):
try:
parsed = ast.literal_eval(candidate)
if isinstance(parsed, list):
raw_plan = parsed
except (ValueError, SyntaxError):
pass
expert_plan = [str(item).strip() for item in raw_plan if item]
elif isinstance(raw_plan, str):
raw_plan = raw_plan.strip()
expert_plan = [raw_plan] if raw_plan else []
if not isinstance(first_obs, str):
first_obs = ""
objectives.append(objective)
query_texts.append(objective if query_source == "objective" else first_obs)
expert_plans.append(expert_plan)
query_embeddings = {}
valid_queries = [(idx, text) for idx, text in enumerate(query_texts) if text and text.strip()]
if valid_queries:
indices, texts = zip(*valid_queries)
emb_matrix = get_embeddings(self.args.retriever, list(texts), 'query')
for emb_idx, query_idx in enumerate(indices):
query_embeddings[query_idx] = emb_matrix[emb_idx]
tasks = []
for idx, (task_type, gamefile, entry) in enumerate(batch_b):
objective = objectives[idx]
retrieved_memories = []
retrieved_indices = []
emb = query_embeddings.get(idx)
if emb is not None and len(memory_bank.memories) > 0:
retrieved_memories, retrieved_indices = memory_bank.retrieve(
emb, use_state_encoder=False
)
tasks.append({
"task_type": task_type,
"gamefile": gamefile,
"objective": objective,
"query": query_texts[idx],
"retrieved_memories": list(retrieved_memories),
"retrieved_indices": list(retrieved_indices),
"expert_plan": list(expert_plans[idx]) if expert_plans else []
})
llm_args = {
"model": getattr(self.args, "model", ""),
"api_base": getattr(self.args, "api_base", ""),
"api_key": getattr(self.args, "api_key", None),
"temperature": getattr(self.config, "alfworld_action_temperature", 0.0),
"top_p": getattr(self.config, "alfworld_action_top_p", 1.0),
"max_tokens": getattr(self.config, "alfworld_action_max_tokens", 32),
"seed": getattr(self.args, "seed", 42)
}
max_steps = int(getattr(self.config, "alfworld_pair_max_steps", 50))
include_inventory = bool(getattr(self.config, "alfworld_include_inventory", True))
results = []
executor = self._get_eval_pool()
futures = {
executor.submit(
run_alfworld_episode,
task["gamefile"],
task["objective"],
task["retrieved_memories"],
max_steps,
llm_args,
include_inventory,
query_source,
task.get("expert_plan") or []
): task for task in tasks
}
for future in tqdm(
as_completed(futures),
total=len(futures),
desc="ALFWorld batch B",
):
task = futures[future]
try:
outcome = future.result()
except Exception as exc:
outcome = {"error": str(exc)}
merged = dict(task)
merged.update(outcome)
results.append(merged)
return results
def _run_single_episode(self, train_data: List[Dict], outer_epoch: int,
inner_epoch: int) -> Dict:
batch_a, batch_b = self._sample_pair()
memory_bank = self._initialize_memory_bank()
local_buffer = PPOBuffer()
step_logs = self._build_memory_from_batch_a(
batch_a=batch_a,
memory_bank=memory_bank,
ppo_buffer=local_buffer,
outer_epoch=outer_epoch,
inner_epoch=inner_epoch
)
batch_b_results = self._run_batch_b(batch_b, memory_bank)
successes = [1.0 if r.get("success") else 0.0 for r in batch_b_results]
avg_reward = float(np.mean(successes)) if successes else 0.0
if self.designer is not None:
memory_snapshot = memory_bank.to_dict()
batch_a_episode_length = len(step_logs)
for result in batch_b_results:
success = bool(result.get("success"))
prediction = "SUCCESS" if success else "FAILED"
query_text = result.get("query")
if not isinstance(query_text, str) or not query_text.strip():
query_text = result.get("objective") or ""
case = DesignerCase(
query_id=f"{result.get('task_type')}::{result.get('gamefile')}",
question=query_text,
ground_truth="task_success",
evidence=result.get("trajectory") or "",
category=None,
memory_bank_snapshot=memory_snapshot,
retrieved_memories=result.get("retrieved_memories") or [],
retrieved_indices=result.get("retrieved_indices") or [],
prediction=prediction,
is_correct=success,
f1_score=1.0 if success else 0.0,
llm_judge_score=1.0 if success else 0.0,
conversation_id=result.get("task_type"),
epoch=outer_epoch * self.config.inner_epochs + inner_epoch,
step=batch_a_episode_length
)
self.designer.case_collector.add_case(case)
redistribute = getattr(self.config, 'redistribute_reward', False)
redistribution_decay = getattr(self.config, 'reward_redistribution_decay', 0.95)
final_reward_last_ratio = getattr(self.config, 'final_reward_last_ratio', 0.0)
local_buffer.finish_episode(
final_reward=avg_reward,
redistribute=redistribute,
redistribution_decay=redistribution_decay,
final_reward_last_ratio=final_reward_last_ratio
)
episode_log = {
'steps': step_logs,
'total_reward': avg_reward,
'final_qa_performance': avg_reward,
'raw_performance': avg_reward,
'batch_b_success': sum(successes),
'batch_b_total': len(successes)
}
op_stats = []
for step in step_logs:
selected_op = step.get('selected_op')
if isinstance(selected_op, list):
for op_name in selected_op:
op_stats.append({'op_name': op_name, 'reward': avg_reward})
else:
op_stats.append({'op_name': selected_op, 'reward': avg_reward})
return {
'episode_log': episode_log,
'local_buffer': local_buffer,
'op_stats': op_stats
}
def get_trainer(args, config) -> BaseTrainer:
if getattr(args, "dataset", None) == "alfworld":
offline_path = getattr(config, "alfworld_offline_data", None) or getattr(args, "alfworld_offline_data", None)
if not offline_path:
raise ValueError("ALFWorld requires --alfworld-offline-data for offline pair training.")
config.alfworld_offline_data = offline_path
return AlfworldPairTrainer(args, config)
return OfflineTrainer(args, config)
"""
Trainer: Training loop with PPO (Proximal Policy Optimization) algorithm
"""
import torch
import torch.optim as optim
import numpy as np
import os
import json
import random
import logging
import multiprocessing as mp
import threading
import ast
from datetime import datetime
from tqdm import tqdm
from typing import List, Dict, Optional, Tuple, Any
from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor, as_completed
import sys
import wandb
import re
sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
from src.controller import PPOController, StateEncoder, OpEncoder, PPOBuffer
from src.memory_bank import MemoryBank
from src.operation_bank import OperationBank
from src.executor import Executor
from src.designer import Designer, DesignerCase, EvolutionSnapshotManager
from src.data_processing import get_processor, DataProcessor
from src.data_processing.alfworld import (
ALFWorldOfflineDataset,
chunk_trajectories_by_tokens,
)
from src.eval import get_evaluator
from rag_utils import (
get_embeddings,
init_context_model,
init_query_model,
set_retriever_flash_attn,
)
from eval_utils import llm_judge
from prompts.prompt_pool import LLM_JUDGE_GENERAL_PROMPT
CHECKPOINT_VERSION = 4
class BaseTrainer:
"""
Trainer for Agentic Memory System
Uses PPO (Proximal Policy Optimization) for controller training
- On-policy learning with trajectory collection
- GAE (Generalized Advantage Estimation) for advantage computation
- Clipped surrogate objective for stable updates
- Multiple update epochs on collected data
"""
def __init__(self, args, config):
self.args = args
self.config = config
self.device = args.device
set_retriever_flash_attn(bool(getattr(config, "use_flash_attn", True)))
# Initialize encoders (each with its own state encoder backbone to reduce thread contention)
encode_batch_size = getattr(config, 'encode_batch_size', 64)
use_flash_attn = bool(getattr(config, "use_flash_attn", True))
self.state_encoder = StateEncoder(
model_name=config.state_encoder,
device=self.device,
fusion_mode=getattr(config, 'state_fusion', 'mean'),
fusion_tau=getattr(config, 'state_fusion_tau', 1.0),
encode_batch_size=encode_batch_size,
use_flash_attn=use_flash_attn
)
self.op_encoder = OpEncoder(
model_name=config.op_encoder,
device=self.device,
encode_batch_size=encode_batch_size,
use_flash_attn=use_flash_attn
)
# Dedicated state encoder for memory bank embeddings (avoid contention with policy encoder)
self.memory_bank_encoder = StateEncoder(
model_name=config.state_encoder,
device=self.device,
fusion_mode=getattr(config, 'state_fusion', 'mean'),
fusion_tau=getattr(config, 'state_fusion_tau', 1.0),
encode_batch_size=encode_batch_size,
use_flash_attn=use_flash_attn
)
# Derive embedding dimensions from actual encoders
state_encoder_dim = self.state_encoder.embedding_dim
op_encoder_dim = self.op_encoder.embedding_dim
# State dim = session_emb + memory_emb (concatenated), both from state_encoder
state_dim = 2 * state_encoder_dim
op_dim = op_encoder_dim
# Update config with actual dimensions for reference
config.state_dim = state_dim
config.op_embedding_dim = op_dim
# PPO Controller