Datasets:
File size: 13,960 Bytes
fe39cc9 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 | """
GradNorm Implementation for Multi-Task Loss Balancing
Based on "GradNorm: Gradient Normalization for Adaptive Loss Balancing in Deep Multitask Networks"
Chen et al., 2018 (https://arxiv.org/abs/1711.02257)
"""
import torch
import torch.nn as nn
import torch.nn.functional as F
from typing import Any, Dict, List, Tuple, Optional
import numpy as np
from collections import deque
import logging
from config.biomarker_config import FlexibleBiomarkerConfig
from model.flexible_multitask_head import FlexibleMultiTaskLoss
logger = logging.getLogger(__name__)
class GradNormLoss(nn.Module):
"""
GradNorm-based multi-task loss balancing.
This implementation extends the FlexibleMultiTaskLoss with GradNorm algorithm
for automatic loss balancing based on gradient magnitudes.
"""
def __init__(
self,
biomarker_config: FlexibleBiomarkerConfig,
class_weights: Dict[str, float] = None,
alpha: float = 0.16,
initial_task_loss_average_window: int = 20,
update_weights_every: int = 10,
normalize_losses: bool = True,
restoring_force_factor: float = 0.1
):
"""
Initialize GradNorm loss.
Args:
biomarker_config: Configuration for biomarkers and tasks
class_weights: Initial class weights for individual losses
alpha: Restoring force strength (typically 0.12-0.16)
initial_task_loss_average_window: Window size for computing initial task loss averages
update_weights_every: Update loss weights every N iterations
normalize_losses: Whether to normalize individual losses
restoring_force_factor: Factor for the restoring force strength
"""
super().__init__()
self.biomarker_config = biomarker_config
self.alpha = alpha
self.update_weights_every = update_weights_every
self.normalize_losses = normalize_losses
self.restoring_force_factor = restoring_force_factor
self.initial_task_loss_average_window = initial_task_loss_average_window
# Create the base multi-task loss
self.base_loss = FlexibleMultiTaskLoss(biomarker_config, class_weights)
# Get task information
self.task_names = self._get_task_names()
self.num_tasks = len(self.task_names)
# Initialize task weights (learnable parameters)
initial_weights = torch.ones(self.num_tasks, dtype=torch.float32)
self.task_weights = nn.Parameter(initial_weights)
# Tracking variables
self.step_count = 0
self.initial_task_losses = {task: deque(maxlen=initial_task_loss_average_window)
for task in self.task_names}
self.initial_losses_computed = False
self.task_loss_averages = None
# For debugging and monitoring
self.weight_history = []
self.loss_ratio_history = []
def to(self, device):
"""Move GradNorm loss to device."""
super().to(device)
self.task_weights.data = self.task_weights.data.to(device)
if self.task_loss_averages is not None:
self.task_loss_averages = self.task_loss_averages.to(device)
return self
def _get_task_names(self) -> List[str]:
"""Get list of all task names from biomarker config."""
task_names = []
# Add binary tasks
for biomarker in self.biomarker_config.binary_biomarkers:
task_names.append(f"binary_{biomarker.name}")
# Add multiclass tasks
for biomarker in self.biomarker_config.multiclass_biomarkers:
task_names.append(f"multiclass_{biomarker.name}")
# Add regression tasks
for biomarker in self.biomarker_config.continuous_biomarkers:
task_names.append(f"regression_{biomarker.name}")
return task_names
def _get_task_losses_from_components(self, loss_components: Dict[str, float]) -> torch.Tensor:
"""Extract individual task losses from loss components dict."""
task_losses = []
for task_name in self.task_names:
if task_name in loss_components:
task_losses.append(loss_components[task_name])
else:
# Handle missing task (shouldn't happen, but safety check)
task_losses.append(0.0)
return torch.tensor(task_losses, dtype=torch.float32, device=self.task_weights.device)
def _get_task_losses_as_tensors(self, predictions: torch.Tensor, targets: torch.Tensor) -> torch.Tensor:
"""Extract individual task losses as tensors (maintaining gradient connection)."""
device = predictions.device
task_losses = []
tensor_layout = self.biomarker_config.get_tensor_layout()
# Binary classification losses
for biomarker in self.biomarker_config.binary_biomarkers:
layout = tensor_layout[biomarker.name]
pred_slice = predictions[:, layout.start_idx:layout.end_idx].squeeze(-1) # [B]
target_slice = targets[:, layout.start_idx:layout.end_idx].squeeze(-1) # [B]
loss_fn = self.base_loss.binary_losses[biomarker.name]
binary_loss = loss_fn(pred_slice, target_slice)
task_losses.append(binary_loss)
# Multiclass classification losses
for biomarker in self.biomarker_config.multiclass_biomarkers:
layout = tensor_layout[biomarker.name]
pred_slice = predictions[:, layout.start_idx:layout.end_idx] # [B, num_classes]
target_slice = targets[:, layout.start_idx:layout.end_idx] # [B, num_classes]
# Convert one-hot targets to class indices
target_indices = torch.argmax(target_slice, dim=1) # [B]
loss_fn = self.base_loss.multiclass_losses[biomarker.name]
multiclass_loss = loss_fn(pred_slice, target_indices)
task_losses.append(multiclass_loss)
# Regression losses
for biomarker in self.biomarker_config.continuous_biomarkers:
layout = tensor_layout[biomarker.name]
pred_slice = predictions[:, layout.start_idx:layout.end_idx].squeeze(-1) # [B]
target_slice = targets[:, layout.start_idx:layout.end_idx].squeeze(-1) # [B]
loss_fn = self.base_loss.regression_losses[biomarker.name]
regression_loss = loss_fn(pred_slice, target_slice)
task_losses.append(regression_loss)
return torch.stack(task_losses)
def _compute_initial_task_losses(self, task_losses: torch.Tensor):
"""Collect initial task losses for computing averages."""
task_losses_cpu = task_losses.detach().cpu().numpy()
for i, task_name in enumerate(self.task_names):
self.initial_task_losses[task_name].append(task_losses_cpu[i])
# Check if we have enough samples to compute averages
min_samples = min(len(losses) for losses in self.initial_task_losses.values())
if min_samples >= self.initial_task_loss_average_window:
self.task_loss_averages = torch.tensor([
np.mean(self.initial_task_losses[task_name])
for task_name in self.task_names
], dtype=torch.float32, device=self.task_weights.device)
self.initial_losses_computed = True
logger.info(
"GradNorm: Initial task loss averages computed: %s",
dict(zip(self.task_names, self.task_loss_averages.cpu().numpy())),
)
def _update_task_weights(self, model: nn.Module, task_losses: torch.Tensor):
"""Update task weights using simplified GradNorm algorithm."""
if not self.initial_losses_computed:
return
device = self.task_weights.device
# Simplified approach: update weights based on loss ratios without gradient computation
# This avoids the gradient computation issues while still providing adaptive balancing
# Compute relative inverse training rates
task_loss_ratios = task_losses / self.task_loss_averages
relative_inverse_training_rates = task_loss_ratios / torch.mean(task_loss_ratios)
# Update weights based on relative training rates
# Higher loss ratio -> higher weight (more attention to struggling tasks)
# Apply restoring force based on relative training rates
weight_updates = (relative_inverse_training_rates ** self.alpha) - 1.0
self.task_weights.data += self.restoring_force_factor * weight_updates
# Renormalize weights to prevent them from growing unboundedly
self.task_weights.data = F.softmax(self.task_weights.data, dim=0) * self.num_tasks
# Store for monitoring
self.weight_history.append(self.task_weights.data.detach().cpu().numpy().copy())
self.loss_ratio_history.append(relative_inverse_training_rates.detach().cpu().numpy().copy())
if len(self.weight_history) % 50 == 0: # Print every 50 updates
logger.info(
"GradNorm Step %s: Weights = %s",
self.step_count,
dict(zip(self.task_names, self.task_weights.data.cpu().numpy())),
)
def forward(self, predictions: torch.Tensor, targets: torch.Tensor,
model: Optional[nn.Module] = None) -> Tuple[torch.Tensor, Dict[str, float]]:
"""
Forward pass with GradNorm loss balancing.
Args:
predictions: Model predictions
targets: Ground truth targets
model: The model (needed for gradient computation)
Returns:
total_loss: Balanced total loss
loss_dict: Dictionary with loss components and weights
"""
# Get individual task losses from base loss
base_total_loss, loss_components = self.base_loss(predictions, targets)
# Extract task losses as tensors (maintaining gradient connection)
task_losses = self._get_task_losses_as_tensors(predictions, targets)
# Collect initial losses if not yet computed
if not self.initial_losses_computed:
self._compute_initial_task_losses(task_losses)
# Update task weights using GradNorm (if model is provided and enough steps have passed)
if (model is not None and
self.initial_losses_computed and
self.step_count % self.update_weights_every == 0 and
self.step_count > 0):
self._update_task_weights(model, task_losses)
# Compute weighted total loss
if self.initial_losses_computed:
# Normalize task losses if requested
if self.normalize_losses:
normalized_task_losses = task_losses / self.task_loss_averages
weighted_losses = self.task_weights * normalized_task_losses
else:
weighted_losses = self.task_weights * task_losses
total_loss = torch.sum(weighted_losses)
else:
# Use equal weighting during initial phase
total_loss = torch.sum(task_losses)
# Update loss components with weights
loss_components['total_loss'] = total_loss.item()
# Add weight information to loss components
if self.initial_losses_computed:
for i, task_name in enumerate(self.task_names):
loss_components[f'weight_{task_name}'] = self.task_weights[i].item()
self.step_count += 1
return total_loss, loss_components
def get_task_weights(self) -> Dict[str, float]:
"""Get current task weights as dictionary."""
if not self.initial_losses_computed:
return {task: 1.0 for task in self.task_names}
return dict(zip(self.task_names, self.task_weights.data.cpu().numpy()))
def get_weight_history(self) -> List[Dict[str, float]]:
"""Get history of task weights for analysis."""
history = []
for weights in self.weight_history:
history.append(dict(zip(self.task_names, weights)))
return history
def reset_weights(self):
"""Reset task weights to uniform distribution."""
with torch.no_grad():
self.task_weights.data.fill_(1.0)
self.initial_losses_computed = False
self.step_count = 0
self.weight_history.clear()
self.loss_ratio_history.clear()
for task_losses in self.initial_task_losses.values():
task_losses.clear()
class GradNormTrainer:
"""
Utility class to help integrate GradNorm with existing training loops.
"""
def __init__(self, gradnorm_loss: GradNormLoss):
self.gradnorm_loss = gradnorm_loss
def compute_loss(self, model: nn.Module, predictions: torch.Tensor,
targets: torch.Tensor) -> Tuple[torch.Tensor, Dict[str, float]]:
"""
Compute loss using GradNorm.
This method should replace the standard criterion(predictions, targets) call.
"""
return self.gradnorm_loss(predictions, targets, model)
def get_training_stats(self) -> Dict[str, Any]:
"""Get training statistics for logging."""
return {
'task_weights': self.gradnorm_loss.get_task_weights(),
'step_count': self.gradnorm_loss.step_count,
'initial_losses_computed': self.gradnorm_loss.initial_losses_computed,
'num_tasks': self.gradnorm_loss.num_tasks
}
|