gst-code-collection / MemSkill /src /controller.py
SitongGong's picture
merge code dirs 1031 (part 3)
4c30587 verified
Raw History Blame Contribute Delete
39 kB
"""
Controller: Trainable agent that selects operations
Uses PPO (Proximal Policy Optimization) for training with dynamic action space
- Dual-encoder architecture: state_net + op_net with interaction layer
- Actor-Critic: policy head + value head
- On-policy learning with GAE (Generalized Advantage Estimation)
- Clipped surrogate objective for stable updates
"""
import torch
import torch.nn as nn
import numpy as np
from typing import List, Tuple, Optional, Dict, Union
from sentence_transformers import SentenceTransformer
from transformers import AutoModel, AutoTokenizer
class PPOBuffer:
"""
Buffer for PPO training
Stores episode trajectories with states, actions, log_probs, values, rewards
Supports both single action (K=1) and top-K action selection:
- actions: List of action indices (single int for K=1, List[int] for K>1)
- log_probs: Joint log probability of selected action(s)
"""
def __init__(self):
self.states = []
self.op_embs = []
self.new_op_masks = []
self.actions = [] # List[int] or List[List[int]] for top-K
self.log_probs = []
self.values = []
self.rewards = []
self.dones = []
def push(self, state_emb: np.ndarray, op_embs: np.ndarray,
action: Union[int, List[int]], log_prob: float, value: float, reward: float = 0.0,
new_op_mask: Optional[np.ndarray] = None):
"""
Store a transition with optional immediate reward (e.g., exploration bonus)
Args:
action: Single action index (int) for K=1, or list of action indices for top-K
log_prob: Joint log probability of selected action(s)
"""
self.states.append(state_emb)
self.op_embs.append(op_embs)
if new_op_mask is None:
new_op_mask = np.zeros(op_embs.shape[0], dtype=np.float32)
self.new_op_masks.append(new_op_mask)
self.actions.append(action)
self.log_probs.append(log_prob)
self.values.append(value)
self.rewards.append(reward) # Can include shaping rewards like exploration bonus
self.dones.append(False)
def merge(self, other: 'PPOBuffer'):
"""Merge another buffer into this one (for parallel episode collection)"""
self.states.extend(other.states)
self.op_embs.extend(other.op_embs)
self.new_op_masks.extend(other.new_op_masks)
self.actions.extend(other.actions)
self.log_probs.extend(other.log_probs)
self.values.extend(other.values)
self.rewards.extend(other.rewards)
self.dones.extend(other.dones)
def finish_episode(self, final_reward: float, redistribute: bool = True,
redistribution_decay: float = 0.9,
final_reward_last_ratio: float = 0.6):
"""
Mark episode as finished and handle final reward.
Args:
final_reward: The delayed reward (e.g., QA performance)
redistribute: If True, spread final reward across all steps in the episode
using exponential decay. This helps with credit assignment
in long horizon settings.
redistribution_decay: Decay factor for reward redistribution (0-1).
Higher values give more credit to later steps.
final_reward_last_ratio: Portion of final_reward added directly to the last
step when redistribute is True. Remainder is
redistributed across all steps.
"""
if len(self.rewards) == 0:
return
# Find the start of the current episode (after last done=True or beginning)
episode_start = 0
for i in range(len(self.dones) - 1, -1, -1):
if self.dones[i]:
episode_start = i + 1
break
episode_length = len(self.rewards) - episode_start
if redistribute and episode_length > 1:
final_reward_last_ratio = max(0.0, min(final_reward_last_ratio, 1.0))
last_reward = final_reward * final_reward_last_ratio
remaining_reward = final_reward - last_reward
if remaining_reward != 0.0:
# Redistribute remaining reward across all steps with exponential decay
# Later steps get more credit than earlier steps
weights = np.array([redistribution_decay ** (episode_length - 1 - i)
for i in range(episode_length)])
weights = weights / weights.sum() # Normalize to sum to 1
for i, w in enumerate(weights):
self.rewards[episode_start + i] += remaining_reward * w
self.rewards[-1] += last_reward
else:
# Original behavior: add all final reward to last step
self.rewards[-1] += final_reward
self.dones[-1] = True
def compute_returns_and_advantages(self, gamma: float = 0.99,
gae_lambda: float = 0.95,
last_value: float = 0.0) -> Tuple[np.ndarray, np.ndarray]:
"""
Compute returns and GAE advantages
Correctly handles multiple episodes in the buffer by resetting GAE at episode boundaries.
Args:
gamma: Discount factor
gae_lambda: GAE lambda parameter
last_value: Value estimate for the state after last step (0 if episode ended)
Returns:
returns: [N] array of discounted returns
advantages: [N] array of GAE advantages
"""
n = len(self.rewards)
if n == 0:
return np.array([]), np.array([])
rewards = np.array(self.rewards)
values = np.array(self.values)
dones = np.array(self.dones, dtype=np.float32)
# Compute GAE with proper episode boundary handling
advantages = np.zeros(n, dtype=np.float32)
last_gae = 0.0
for t in reversed(range(n)):
if t == n - 1:
next_value = last_value
else:
next_value = values[t + 1]
# Non-terminal mask: 0 if done (episode ended), 1 otherwise
next_non_terminal = 1.0 - dones[t]
# TD error
delta = rewards[t] + gamma * next_value * next_non_terminal - values[t]
# GAE: reset last_gae when episode ends (next_non_terminal = 0)
# This prevents advantage from bleeding across episode boundaries
advantages[t] = last_gae = delta + gamma * gae_lambda * next_non_terminal * last_gae
# Returns = advantages + values
returns = advantages + values
return returns, advantages
def get_batch(self) -> Dict:
"""
Get all data as a batch dict
For top-K actions:
- If actions are lists (K>1), returns 'actions' as 2D array [N, K]
- If actions are ints (K=1), returns 'actions' as 1D array [N] for backward compatibility
"""
# Determine if we have top-K actions (list) or single actions (int)
if len(self.actions) > 0 and isinstance(self.actions[0], (list, np.ndarray)):
# Top-K case: convert to 2D array [N, K]
actions_array = np.array(self.actions)
else:
# Single action case: 1D array [N]
actions_array = np.array(self.actions)
return {
'states': self.states,
'op_embs': self.op_embs,
'new_op_masks': self.new_op_masks,
'actions': actions_array,
'log_probs': np.array(self.log_probs),
'values': np.array(self.values),
'rewards': np.array(self.rewards),
'dones': np.array(self.dones)
}
def clear(self):
"""Clear the buffer"""
self.states = []
self.op_embs = []
self.new_op_masks = []
self.actions = []
self.log_probs = []
self.values = []
self.rewards = []
self.dones = []
def __len__(self):
return len(self.states)
class PPOController(nn.Module):
"""
PPO Controller with Actor-Critic architecture for operation selection
- Dual-encoder: state_net + op_net for handling dynamic action space
- Actor (Policy): outputs action logits for each operation
- Critic (Value): outputs state value V(s)
- Uses clipped surrogate objective for stable policy updates
- Supports top-K action selection (action_top_k parameter)
"""
def __init__(self, state_dim: int = 768, op_dim: int = 768,
hidden_dim: int = 256, device: str = 'cuda',
gamma: float = 0.99, gae_lambda: float = 0.95,
clip_epsilon: float = 0.2, entropy_coef: float = 0.01,
value_coef: float = 0.5, vf_clip: float = 0.0,
new_action_p_min: float = 0.0, new_action_delta_max: float = 0.0,
action_top_k: int = 1):
super(PPOController, self).__init__()
self.state_dim = state_dim
self.op_dim = op_dim
self.hidden_dim = hidden_dim
self.device = device
# PPO hyperparameters
self.gamma = gamma
self.gae_lambda = gae_lambda
self.clip_epsilon = clip_epsilon
self.entropy_coef = entropy_coef
self.value_coef = value_coef
self.vf_clip = vf_clip
self.new_action_p_min = new_action_p_min
self.new_action_delta_max = new_action_delta_max
self.new_action_bias_scale = 0.0
self.action_top_k = action_top_k # Number of top actions to select per step
# State encoder network (shared backbone)
self.state_net = nn.Sequential(
nn.Linear(state_dim, hidden_dim),
nn.ReLU(),
nn.Linear(hidden_dim, hidden_dim),
nn.ReLU()
)
# Operation encoder network
self.op_net = nn.Sequential(
nn.Linear(op_dim, hidden_dim),
nn.ReLU(),
nn.Linear(hidden_dim, hidden_dim),
nn.ReLU()
)
# Actor head: computes action logits from [state_h, op_h] pairs
self.actor_head = nn.Sequential(
nn.Linear(hidden_dim * 2, hidden_dim),
nn.ReLU(),
nn.Linear(hidden_dim, 1) # Output score for each (state, op) pair
)
# Critic head: computes state value from state_h only
self.critic_head = nn.Sequential(
nn.Linear(hidden_dim, hidden_dim),
nn.ReLU(),
nn.Linear(hidden_dim, 1)
)
self.to(device)
def encode_state(self, state_embedding: torch.Tensor) -> torch.Tensor:
"""Encode state"""
return self.state_net(state_embedding)
def encode_ops(self, op_embeddings: torch.Tensor) -> torch.Tensor:
"""Encode operations"""
return self.op_net(op_embeddings)
def get_action_logits(self, state_h: torch.Tensor, op_h: torch.Tensor,
mask: Optional[torch.Tensor] = None) -> torch.Tensor:
"""
Compute action logits for each operation
state_h: [B, hidden_dim]
op_h: [B, num_ops, hidden_dim]
mask: [B, num_ops] - 1 for valid ops, 0 for padding
Returns: [B, num_ops] logits
"""
batch_size = state_h.shape[0]
num_ops = op_h.shape[1]
# Expand state to match ops
state_expanded = state_h.unsqueeze(1).expand(-1, num_ops, -1) # [B, num_ops, hidden_dim]
# Concatenate
combined = torch.cat([state_expanded, op_h], dim=-1) # [B, num_ops, hidden_dim*2]
# Compute logits
logits = self.actor_head(combined).squeeze(-1) # [B, num_ops]
# Apply mask (set padded positions to large negative value)
if mask is not None:
logits = logits.masked_fill(mask == 0, float('-inf'))
return logits
def get_value(self, state_h: torch.Tensor) -> torch.Tensor:
"""
Compute state value
state_h: [B, hidden_dim]
Returns: [B] values
"""
return self.critic_head(state_h).squeeze(-1)
def set_new_action_bias_scale(self, bias_scale: float):
"""Set current bias scale for new-action exploration."""
self.new_action_bias_scale = float(bias_scale)
def _apply_new_action_bias(self, logits: torch.Tensor,
new_op_mask: torch.Tensor) -> torch.Tensor:
if new_op_mask is None:
return logits
if self.new_action_p_min <= 0.0 or self.new_action_delta_max <= 0.0:
return logits
if self.new_action_bias_scale <= 0.0:
return logits
if logits.dim() == 1:
logits_in = logits.unsqueeze(0)
mask_in = new_op_mask.unsqueeze(0)
else:
logits_in = logits
mask_in = new_op_mask
mask_in = mask_in.float()
mask_sum = mask_in.sum(dim=-1)
has_new = mask_sum > 0
if not torch.any(has_new):
return logits
with torch.no_grad():
probs = torch.softmax(logits_in, dim=-1)
p_new = (probs * mask_in).sum(dim=-1)
target = float(self.new_action_p_min)
need_bias = has_new & (p_new < target)
if not torch.any(need_bias):
return logits
eps = 1e-8
safe_p = torch.where(need_bias, p_new, torch.ones_like(p_new))
delta = torch.log(target / (safe_p + eps))
delta = torch.where(need_bias, delta, torch.zeros_like(delta))
delta = torch.clamp(delta, min=0.0, max=float(self.new_action_delta_max))
delta = delta * float(self.new_action_bias_scale)
logits_out = logits_in + delta.unsqueeze(-1) * mask_in
if logits.dim() == 1:
return logits_out[0]
return logits_out
def _compute_topk_log_prob(self, logits: torch.Tensor, actions: torch.Tensor) -> torch.Tensor:
"""
Compute joint log probability for top-K action selection (without replacement).
For Gumbel-top-k sampling (sampling K items without replacement), the joint
probability is:
P(a1, a2, ..., aK) = p(a1) × p(a2)/(1-p(a1)) × p(a3)/(1-p(a1)-p(a2)) × ...
In log form:
log P = Σ_i [log p(ai) - log(1 - Σ_{j<i} p(aj))]
This correctly matches the Gumbel-top-k sampling distribution used in forward().
Args:
logits: [B, num_ops] or [num_ops] action logits
actions: [B, K] or [K] indices of selected actions
Returns:
[B] or scalar joint log probabilities
"""
single_batch = logits.dim() == 1
if single_batch:
logits = logits.unsqueeze(0) # [1, num_ops]
actions = actions.unsqueeze(0) # [1, K]
batch_size = logits.shape[0]
k = actions.shape[1]
# Compute softmax probabilities
probs = torch.softmax(logits, dim=-1) # [B, num_ops]
# Gather probs for selected actions in order
selected_probs = torch.gather(probs, dim=-1, index=actions) # [B, K]
# Compute log probability for without-replacement sampling
# log P = Σ_i [log p(ai) - log(1 - Σ_{j<i} p(aj))]
joint_log_prob = torch.zeros(batch_size, device=logits.device)
remaining_prob = torch.ones(batch_size, device=logits.device) # 1 - cumsum of selected probs
eps = 1e-8
for i in range(k):
p_i = torch.clamp(selected_probs[:, i], min=eps)
# log P(ai | a1,...,ai-1 selected) = log(p_i / remaining_prob)
# = log(p_i) - log(remaining_prob)
denom = torch.clamp(remaining_prob, min=eps)
joint_log_prob = joint_log_prob + torch.log(p_i) - torch.log(denom)
remaining_prob = torch.clamp(remaining_prob - p_i, min=eps)
if single_batch:
return joint_log_prob[0] # scalar
return joint_log_prob
def _compute_topk_stats(self, logits: torch.Tensor,
actions: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
"""
Compute top-K diagnostics from the action probabilities.
Returns:
topk_entropy: [B] entropy of normalized top-K probabilities
topk_mass: [B] total probability mass assigned to top-K actions
topk_bin_entropy: [B] binary entropy between top-K and tail mass
"""
if logits.dim() == 1:
logits = logits.unsqueeze(0)
if actions.dim() == 1:
actions = actions.unsqueeze(1)
probs = torch.softmax(logits, dim=-1) # [B, num_ops]
selected_probs = torch.gather(probs, dim=-1, index=actions) # [B, K]
mass_topk = selected_probs.sum(dim=-1) # [B]
eps = 1e-8
safe_mass = mass_topk.clamp(min=eps)
normalized = (selected_probs / safe_mass.unsqueeze(-1)).clamp(min=eps)
topk_entropy = -(normalized * torch.log(normalized)).sum(dim=-1)
m = mass_topk.clamp(min=eps, max=1 - eps)
topk_bin_entropy = -(m * torch.log(m) + (1 - m) * torch.log(1 - m))
return topk_entropy, mass_topk, topk_bin_entropy
def forward(self, state_embedding: torch.Tensor,
op_embeddings: torch.Tensor,
deterministic: bool = False,
new_op_mask: Optional[torch.Tensor] = None
) -> Tuple[Union[int, List[int]], float, float]:
"""
Forward pass with action selection (supports top-K)
Args:
state_embedding: [state_dim]
op_embeddings: [num_ops, op_dim]
deterministic: If True, always select top actions by logits
new_op_mask: Optional mask for new action bias
Returns:
- action: int (if K=1) or List[int] (if K>1) selected action indices
- log_prob: float, joint log probability of selected action(s)
- value: float, state value estimate
"""
# Add batch dimension
state_emb = state_embedding.unsqueeze(0) # [1, state_dim]
op_embs = op_embeddings.unsqueeze(0) # [1, num_ops, op_dim]
# Encode
state_h = self.encode_state(state_emb) # [1, hidden_dim]
op_h = self.encode_ops(op_embs) # [1, num_ops, hidden_dim]
# Get action logits and value
logits = self.get_action_logits(state_h, op_h) # [1, num_ops]
value = self.get_value(state_h) # [1]
logits = logits[0] # [num_ops]
value = value[0] # scalar
if new_op_mask is not None:
if not torch.is_tensor(new_op_mask):
new_op_mask = torch.tensor(new_op_mask, dtype=torch.float32, device=logits.device)
else:
new_op_mask = new_op_mask.to(logits.device)
logits = self._apply_new_action_bias(logits, new_op_mask)
num_ops = logits.shape[0]
k = min(self.action_top_k, num_ops) # Can't select more than available ops
if k == 1:
# Original single-action behavior
dist = torch.distributions.Categorical(logits=logits)
if deterministic:
action = torch.argmax(logits).item()
else:
action = dist.sample().item()
log_prob = dist.log_prob(torch.tensor(action, device=self.device)).item()
return action, log_prob, value.item()
else:
# Top-K action selection
if deterministic:
# Select top-K by logits
_, top_k_indices = torch.topk(logits, k)
actions = top_k_indices.tolist()
else:
# Sample K actions without replacement using Gumbel-top-k trick
# This provides proper sampling from the categorical distribution
gumbel = torch.distributions.Gumbel(0, 1).sample(logits.shape).to(logits.device)
perturbed = logits + gumbel
_, top_k_indices = torch.topk(perturbed, k)
actions = top_k_indices.tolist()
# Compute joint log probability
actions_tensor = torch.tensor(actions, device=self.device)
log_prob = self._compute_topk_log_prob(logits, actions_tensor).item()
return actions, log_prob, value.item()
def evaluate_actions(self, state_embs: torch.Tensor, op_embs: torch.Tensor,
actions: torch.Tensor, op_masks: Optional[torch.Tensor] = None,
new_op_masks: Optional[torch.Tensor] = None
) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor, Dict[str, torch.Tensor]]:
"""
Evaluate actions for PPO update (supports top-K actions)
Args:
state_embs: [B, state_dim]
op_embs: [B, max_ops, op_dim]
actions: [B] for single action or [B, K] for top-K actions
op_masks: [B, max_ops] - 1 for valid, 0 for padding
Returns:
log_probs: [B] log probabilities of taken action(s)
values: [B] state values
entropy: [B] policy entropy
topk_stats: dict with top-K diagnostics (entropy/mass/bin-entropy)
"""
# Encode
state_h = self.encode_state(state_embs) # [B, hidden_dim]
op_h = self.encode_ops(op_embs) # [B, max_ops, hidden_dim]
# Get logits and values
logits = self.get_action_logits(state_h, op_h, mask=op_masks) # [B, max_ops]
values = self.get_value(state_h) # [B]
if new_op_masks is not None:
logits = self._apply_new_action_bias(logits, new_op_masks)
# Compute log probs and entropy
dist = torch.distributions.Categorical(logits=logits)
entropy = dist.entropy()
# Handle single action [B] vs top-K actions [B, K]
if actions.dim() == 1:
# Single action case (K=1)
log_probs = dist.log_prob(actions)
else:
# Top-K case: compute joint log probability
log_probs = self._compute_topk_log_prob(logits, actions)
with torch.no_grad():
topk_entropy, topk_mass, topk_bin_entropy = self._compute_topk_stats(
logits.detach(), actions
)
topk_stats = {
'topk_entropy': topk_entropy,
'topk_mass': topk_mass,
'topk_bin_entropy': topk_bin_entropy,
}
return log_probs, values, entropy, topk_stats
def compute_ppo_loss(self, batch: Dict, returns: np.ndarray,
advantages: np.ndarray) -> Tuple[torch.Tensor, Dict]:
"""
Compute PPO loss with value function clipping
Args:
batch: dict with states, op_embs, actions, log_probs, values (old)
returns: [N] array of returns
advantages: [N] array of advantages
Returns:
total_loss: combined loss
loss_info: dict with individual loss components
"""
n = len(batch['states'])
# Handle variable number of operations (dynamic action space)
op_dim = batch['op_embs'][0].shape[1]
max_ops = max(op.shape[0] for op in batch['op_embs'])
# Pad op_embs and create masks
op_embs_padded = np.zeros((n, max_ops, op_dim), dtype=np.float32)
op_masks = np.zeros((n, max_ops), dtype=np.float32)
new_op_masks_padded = None
if 'new_op_masks' in batch:
new_op_masks_padded = np.zeros((n, max_ops), dtype=np.float32)
for i, op in enumerate(batch['op_embs']):
n_ops = op.shape[0]
op_embs_padded[i, :n_ops] = op
op_masks[i, :n_ops] = 1.0
if new_op_masks_padded is not None:
new_mask = batch['new_op_masks'][i]
if new_mask is not None:
new_op_masks_padded[i, :n_ops] = new_mask
# Convert to tensors
state_embs = torch.FloatTensor(np.array(batch['states'])).to(self.device)
op_embs = torch.FloatTensor(op_embs_padded).to(self.device)
op_masks = torch.FloatTensor(op_masks).to(self.device)
new_op_masks = None
if new_op_masks_padded is not None:
new_op_masks = torch.FloatTensor(new_op_masks_padded).to(self.device)
actions = torch.LongTensor(batch['actions']).to(self.device)
old_log_probs = torch.FloatTensor(batch['log_probs']).to(self.device)
old_values = torch.FloatTensor(batch['values']).to(self.device)
returns_t = torch.FloatTensor(returns).to(self.device)
advantages_t = torch.FloatTensor(advantages).to(self.device)
# NOTE: Advantages should already be normalized at the full-batch level
# in trainer.py before minibatch splitting. Do NOT normalize again here,
# as per-minibatch normalization introduces inconsistent scales.
# Evaluate actions
new_log_probs, values, entropy, topk_stats = self.evaluate_actions(
state_embs, op_embs, actions, op_masks, new_op_masks
)
# Policy loss (clipped surrogate objective)
ratio = torch.exp(new_log_probs - old_log_probs)
surr1 = ratio * advantages_t
surr2 = torch.clamp(ratio, 1.0 - self.clip_epsilon, 1.0 + self.clip_epsilon) * advantages_t
policy_loss = -torch.min(surr1, surr2).mean()
# Value loss (optional clipping)
if self.vf_clip is not None and self.vf_clip > 0:
value_pred_clipped = old_values + torch.clamp(
values - old_values, -self.vf_clip, self.vf_clip
)
value_loss_unclipped = (values - returns_t) ** 2
value_loss_clipped = (value_pred_clipped - returns_t) ** 2
value_loss = 0.5 * torch.max(value_loss_unclipped, value_loss_clipped).mean()
else:
value_loss = 0.5 * ((values - returns_t) ** 2).mean()
# Entropy bonus (encourage exploration)
entropy_loss = -entropy.mean()
# Total loss
total_loss = policy_loss + self.value_coef * value_loss + self.entropy_coef * entropy_loss
# Compute explained variance for value function quality
with torch.no_grad():
explained_var = 1 - (returns_t - values).var() / (returns_t.var() + 1e-8)
loss_info = {
'policy_loss': policy_loss.item(),
'value_loss': value_loss.item(),
'entropy': entropy.mean().item(),
'topk_entropy': topk_stats['topk_entropy'].mean().item(),
'topk_mass': topk_stats['topk_mass'].mean().item(),
'topk_bin_entropy': topk_stats['topk_bin_entropy'].mean().item(),
'approx_kl': ((old_log_probs - new_log_probs).mean()).item(),
'clip_frac': ((ratio - 1.0).abs() > self.clip_epsilon).float().mean().item(),
'explained_variance': explained_var.item(),
'value_mean': values.mean().item(),
'return_mean': returns_t.mean().item(),
'advantage_mean': advantages_t.mean().item(),
}
return total_loss, loss_info
# Backward compatibility alias
Controller = PPOController
class BaseTextEncoder:
"""
Base text encoder that holds the shared state encoder backbone.
This class can be shared between StateEncoder and OpEncoder to avoid
loading multiple copies of the same model.
"""
def __init__(self, model_name: str = "allenai/longformer-base-4096", device: str = 'cuda',
encode_batch_size: int = 64, use_flash_attn: bool = True):
self.model_name = model_name
self.device = device
self.encode_batch_size = encode_batch_size
self.use_flash_attn = bool(use_flash_attn)
model_name_lower = model_name.lower()
self._use_qwen_embedding = "qwen3-embedding" in model_name_lower
self._use_sentence_transformer = (
model_name.startswith("sentence-transformers/")
or self._use_qwen_embedding
)
if self._use_sentence_transformer:
if self._use_qwen_embedding:
if torch.cuda.is_available() and torch.cuda.is_bf16_supported():
torch_dtype = torch.bfloat16
else:
torch_dtype = torch.float16
model_kwargs = {"torch_dtype": torch_dtype}
if self.use_flash_attn:
model_kwargs["attn_implementation"] = "flash_attention_2"
tokenizer_kwargs = {"padding_side": "left"}
if str(device).startswith("cuda"):
self.model = SentenceTransformer(
model_name,
device=device,
model_kwargs=model_kwargs,
tokenizer_kwargs=tokenizer_kwargs,
)
else:
model_kwargs["device_map"] = "auto"
self.model = SentenceTransformer(
model_name,
device=device,
model_kwargs=model_kwargs,
tokenizer_kwargs=tokenizer_kwargs,
)
else:
self.model = SentenceTransformer(model_name, device=device)
self._embedding_dim = self.model.get_sentence_embedding_dimension()
self.tokenizer = None
else:
self.tokenizer = AutoTokenizer.from_pretrained(model_name)
self.model = AutoModel.from_pretrained(model_name)
self.model.to(device)
self.model.eval()
self._embedding_dim = self.model.config.hidden_size
@property
def embedding_dim(self) -> int:
return self._embedding_dim
def _mean_pooling(self, model_output: torch.Tensor, attention_mask: torch.Tensor) -> torch.Tensor:
"""Apply mean pooling to get sentence embedding from token embeddings"""
token_embeddings = model_output.last_hidden_state
input_mask_expanded = attention_mask.unsqueeze(-1).expand(token_embeddings.size()).float()
sum_embeddings = torch.sum(token_embeddings * input_mask_expanded, dim=1)
sum_mask = torch.clamp(input_mask_expanded.sum(dim=1), min=1e-9)
return sum_embeddings / sum_mask
def encode(self, texts: Union[str, List[str]], batch_size: Optional[int] = None) -> np.ndarray:
"""
Encode text(s) using the underlying model with batch processing.
Args:
texts: Single text or list of texts to encode
batch_size: Override default batch size (default: self.encode_batch_size)
Returns:
numpy array of embeddings
"""
if isinstance(texts, str):
texts = [texts]
if len(texts) == 0:
return np.zeros((0, self._embedding_dim), dtype=np.float32)
if batch_size is None:
batch_size = self.encode_batch_size
if self._use_sentence_transformer:
return self.model.encode(texts, convert_to_numpy=True, batch_size=batch_size)
else:
# Process in batches to avoid OOM
all_embeddings = []
for i in range(0, len(texts), batch_size):
batch_texts = texts[i:i + batch_size]
with torch.no_grad():
encoded = self.tokenizer(
batch_texts,
padding=True,
truncation=True,
max_length=4096,
return_tensors='pt'
)
encoded = {k: v.to(self.device) for k, v in encoded.items()}
outputs = self.model(**encoded)
embeddings = self._mean_pooling(outputs, encoded['attention_mask'])
all_embeddings.append(embeddings.cpu().numpy())
return np.vstack(all_embeddings) if len(all_embeddings) > 1 else all_embeddings[0]
class StateEncoder:
"""
Encodes session + retrieved memories into state embedding.
Supports HuggingFace encoder backbones and SentenceTransformer models.
Can optionally use a shared BaseTextEncoder to avoid loading multiple model copies.
"""
def __init__(self, model_name: str = "allenai/longformer-base-4096", device: str = 'cuda',
fusion_mode: str = "mean", fusion_tau: float = 1.0,
base_encoder: Optional['BaseTextEncoder'] = None,
encode_batch_size: int = 64, use_flash_attn: bool = True):
self.fusion_mode = fusion_mode
self.fusion_tau = fusion_tau
if base_encoder is not None:
# Use shared encoder
self._base_encoder = base_encoder
self.model_name = base_encoder.model_name
self.device = base_encoder.device
else:
# Create own encoder
self._base_encoder = BaseTextEncoder(
model_name=model_name,
device=device,
encode_batch_size=encode_batch_size,
use_flash_attn=use_flash_attn
)
self.model_name = model_name
self.device = device
@property
def embedding_dim(self) -> int:
"""Get the embedding dimension of the encoder"""
return self._base_encoder.embedding_dim
def _encode_texts(self, texts: Union[str, List[str]]) -> np.ndarray:
"""Encode text(s) using the underlying model"""
return self._base_encoder.encode(texts)
def _fuse_memory_embeddings(self, session_emb: np.ndarray, memory_embs: np.ndarray,
fusion_mode: str, fusion_tau: float) -> np.ndarray:
mem_arr = np.asarray(memory_embs)
if mem_arr.ndim == 1:
mem_arr = mem_arr.reshape(1, -1)
if fusion_mode == "mean":
return np.mean(mem_arr, axis=0)
if fusion_mode == "sim_weighted":
sess = session_emb.astype(np.float32)
mem = mem_arr.astype(np.float32)
sess_norm = sess / (np.linalg.norm(sess) + 1e-8)
mem_norms = np.linalg.norm(mem, axis=1, keepdims=True)
mem_norm = mem / (mem_norms + 1e-8)
sims = np.dot(mem_norm, sess_norm)
tau = max(float(fusion_tau), 1e-8)
sims = sims / tau
sims = sims - np.max(sims)
weights = np.exp(sims).astype(np.float32)
weights = weights / (weights.sum() + 1e-8)
return np.sum(mem * weights[:, None], axis=0)
raise ValueError(f"Unknown fusion_mode: {fusion_mode}")
def encode(self, session_text: str, retrieved_memories: List[str],
session_embedding: Optional[np.ndarray] = None,
memory_embeddings: Optional[Union[np.ndarray, List[np.ndarray]]] = None,
fusion_mode: Optional[str] = None,
fusion_tau: Optional[float] = None) -> np.ndarray:
"""
Encode state from session and retrieved memories.
Strategy: Encode session and memories separately, then concatenate.
If precomputed embeddings are provided, reuse them to skip redundant encoding.
fusion_mode controls how memory embeddings are combined.
Returns: state embedding vector [session_emb || memory_emb]
"""
if fusion_mode is None:
fusion_mode = self.fusion_mode
if fusion_tau is None:
fusion_tau = self.fusion_tau
# Encode current session if not provided
if session_embedding is None:
session_emb = self._encode_texts(session_text)
if session_emb.ndim == 2:
session_emb = session_emb[0]
else:
session_emb = session_embedding
if session_emb.ndim == 2:
session_emb = session_emb[0]
memory_emb = None
mem_arr = None
if memory_embeddings is not None:
if isinstance(memory_embeddings, list):
if len(memory_embeddings) == 0:
memory_embeddings = None
else:
memory_embeddings = np.vstack(memory_embeddings)
if memory_embeddings is not None:
mem_arr = np.asarray(memory_embeddings)
if mem_arr.size == 0:
mem_arr = None
if mem_arr is None:
if len(retrieved_memories) == 0:
# No memories retrieved, use zero vector for memory part
embedding_dim = session_emb.shape[0]
memory_emb = np.zeros(embedding_dim, dtype=np.float32)
else:
# Encode each retrieved memory separately and average
mem_arr = self._encode_texts(retrieved_memories)
if memory_emb is None:
memory_emb = self._fuse_memory_embeddings(
session_emb=session_emb,
memory_embs=mem_arr,
fusion_mode=fusion_mode,
fusion_tau=fusion_tau
)
# Concatenate session and memory embeddings
state_emb = np.concatenate([session_emb, memory_emb], axis=0)
return state_emb
class OpEncoder:
"""
Encodes operation descriptions into embeddings.
Supports HuggingFace encoder backbones and SentenceTransformer models.
Can optionally use a shared BaseTextEncoder to avoid loading multiple model copies.
"""
def __init__(self, model_name: str = "allenai/longformer-base-4096", device: str = 'cuda',
base_encoder: Optional['BaseTextEncoder'] = None,
encode_batch_size: int = 64, use_flash_attn: bool = True):
if base_encoder is not None:
# Use shared encoder
self._base_encoder = base_encoder
self.model_name = base_encoder.model_name
self.device = base_encoder.device
else:
# Create own encoder
self._base_encoder = BaseTextEncoder(
model_name=model_name,
device=device,
encode_batch_size=encode_batch_size,
use_flash_attn=use_flash_attn
)
self.model_name = model_name
self.device = device
@property
def embedding_dim(self) -> int:
"""Get the embedding dimension of the encoder"""
return self._base_encoder.embedding_dim
def encode(self, op_descriptions: List[str]) -> np.ndarray:
"""
Encode operation descriptions
Returns: [num_ops, op_dim]
"""
return self._base_encoder.encode(op_descriptions)
def encode_single(self, op_description: str) -> np.ndarray:
"""Encode single operation"""
emb = self._base_encoder.encode(op_description)
if emb.ndim == 2:
return emb[0]
return emb