src/training/train.py

"""
The main training script for training on synthetic data
"""

import argparse
import multiprocessing
import os
import logging
from pathlib import Path
import random

import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torch.utils.tensorboard import SummaryWriter
from tqdm import tqdm  # pylint: disable=unused-import
from torchmetrics.functional import(
    scale_invariant_signal_noise_ratio as si_snr,
    signal_noise_ratio as snr,
    signal_distortion_ratio as sdr,
    scale_invariant_signal_distortion_ratio as si_sdr)

from src.helpers import utils
from src.training.eval import test_epoch

def get_active_phase(training_phases, epoch):
    """Determine which training phase is active for the given epoch.
    Phases must be sorted by start_epoch ascending."""
    if not training_phases:
        return None
    active_phase = None
    for phase in training_phases:
        if epoch >= phase['start_epoch']:
            active_phase = phase
        else:
            break
    return active_phase

def train_epoch(model: nn.Module, device: torch.device,
                optimizer: optim.Optimizer,
                train_loader: torch.utils.data.dataloader.DataLoader,
                n_items: int, epoch: int = 0,
                writer: SummaryWriter = None) -> float:

    """
    Train a single epoch.
    """
    # Set the model to training.
    model.train()

    # Training loop
    losses = []
    metrics = {}

    tensorboard_trace_handler = torch.profiler.tensorboard_trace_handler(
        writer.log_dir)
    with tqdm(total=len(train_loader), desc='Train', ncols=100) as t:
    #     with torch.profiler.profile(
    #         schedule=torch.profiler.schedule(
    #             skip_first=10,
    #             wait=2,
    #             warmup=2,
    #             active=6,
    #             repeat=2),
    #         on_trace_ready=tensorboard_trace_handler,
    #         profile_memory=True,
    #         with_stack=True
    #     ) as profiler:
            for batch_idx, (inp, tgt) in enumerate(train_loader):
                # Move data to device
                inp, tgt = train_loader.dataset.to(inp, tgt, device)

                # Reset grad
                optimizer.zero_grad()

                # Run through the model
                output = model(inp)

                # Compute loss
                loss = network.loss(output, tgt)

                losses.append(loss.item())

                # Backpropagation
                loss.backward()

                # Gradient clipping
                torch.nn.utils.clip_grad_norm_(model.parameters(), 0.5)

                # Update the weights
                optimizer.step()

                # Compute metrics
                output = train_loader.dataset.output_detach(output)
                metrics_batch = network.metrics(inp, output, tgt)
                for k in metrics_batch.keys():
                    if not k in metrics:
                        metrics[k] = metrics_batch[k]
                    else:
                        metrics[k] += metrics_batch[k]

                output = train_loader.dataset.output_to(output, 'cpu')
                inp, tgt = train_loader.dataset.to(inp, tgt, 'cpu')
                if writer is not None and batch_idx == 0:
                    train_loader.dataset.tensorboard_add_sample(
                        writer, tag='Train',
                        sample=(inp, output, tgt),
                        step=epoch)

                # Step the profiler
                # profiler.step()

                # Show current loss in the progress meter
                t.set_postfix(loss='%.05f'%loss.item())
                t.update()

                if n_items is not None and batch_idx == n_items:
                    break

    avg_metrics = {k: np.mean(metrics[k]) for k in metrics.keys()}
    avg_metrics['loss'] = np.mean(losses)
    avg_metrics_str = "Train:"
    for m in avg_metrics.keys():
        avg_metrics_str += ' %s=%.04f' % (m, avg_metrics[m])
    logging.info(avg_metrics_str)

    return avg_metrics

def train(args: argparse.Namespace):
    """
    Train the network.
    """
    # Load dataset
    # Import and instantiate the training dataset class dynamically based on config
    # utils.import_attr() loads the dataset class specified in args.train_dataset
    # then instantiates it with the parameters from args.train_data_args
    data_train = utils.import_attr(args.train_dataset)(**args.train_data_args)
    logging.info("Loaded train dataset containing %d elements" %
                 (len(data_train)))

    # Phase-wise training setup
    training_phases = getattr(args, 'training_phases', None)
    if training_phases:
        for i in range(1, len(training_phases)):
            assert training_phases[i]['start_epoch'] > training_phases[i-1]['start_epoch'], \
                "training_phases must be sorted by start_epoch in ascending order"
        logging.info("Phase-wise training enabled with %d phases:" % len(training_phases))
        for phase in training_phases:
            logging.info("  Epoch %d+: %s | speech=[%d, %d] distractors=[%d, %d]" % (
                phase['start_epoch'], phase['name'],
                phase['snr_config']['speech']['min'], phase['snr_config']['speech']['max'],
                phase['snr_config']['distractors']['min'], phase['snr_config']['distractors']['max']))
    else:
        logging.info("No training phases defined. Using static snr_config from train_data_args.")
    _current_phase_name = None

    # Import and instantiate the validation dataset class dynamically based on config
    # Similar to training dataset but uses validation-specific parameters
    data_val = utils.import_attr(args.val_dataset)(**args.val_data_args)
    logging.info("Loaded test dataset containing %d elements" %
                 (len(data_val)))

    # Set up the device and workers.
    # Determine if CUDA should be used based on args and availability
    use_cuda = args.use_cuda and torch.cuda.is_available()
    if use_cuda:
        # Get GPU IDs to use - either from args or use all available GPUs
        gpu_ids = args.gpu_ids if args.gpu_ids is not None\
                        else range(torch.cuda.device_count())
        # Convert to list of device IDs
        device_ids = [_ for _ in gpu_ids]
        # Enable data parallel training if multiple GPUs are available
        data_parallel = len(device_ids) > 1
        # Set primary device to first GPU in the list
        device = 'cuda:%d' % device_ids[0]
        # Set the current CUDA device to the primary device
        torch.cuda.set_device(device_ids[0])
        logging.info("Using CUDA devices: %s" % str(device_ids))
    else:
        # Fall back to CPU if CUDA is not available or not requested
        data_parallel = False
        device = torch.device('cpu')
        logging.info("Using device: CPU")

    # Set multiprocessing params
    num_workers = min(multiprocessing.cpu_count(), args.n_workers)
    kwargs = {
        'num_workers': num_workers,
        'pin_memory': True
    } if use_cuda else {}

    # Set up data loaders
    #print(args.batch_size, args.eval_batch_size)
    train_loader = torch.utils.data.DataLoader(
        data_train, batch_size=args.batch_size, shuffle=True,
        collate_fn=data_train.collate_fn, **kwargs)
    val_loader = torch.utils.data.DataLoader(
        data_val, batch_size=args.eval_batch_size, collate_fn=data_val.collate_fn,
        **kwargs)

    # Set up model
    model = network.Net(**args.model_params)

    # Count separation model parameters (excluding CLAP)
    sep_trainable = sum(p.numel() for p in model.parameters() if p.requires_grad)
    sep_total = sum(p.numel() for p in model.parameters())
    sep_frozen = sep_total - sep_trainable
    
    logging.info("=" * 60)
    logging.info("MODEL PARAMETERS")
    logging.info("=" * 60)
    logging.info(f"Separation Model:")
    logging.info(f"  Total:     {sep_total:>12,} parameters")
    logging.info(f"  Trainable: {sep_trainable:>12,} parameters")
    logging.info(f"  Frozen:    {sep_frozen:>12,} parameters")
    
    # Initialize CLAP model and count its parameters
    # This triggers CLAP loading by encoding a dummy label
    try:
        dummy_clap_init = model._get_text_encoder(torch.device(device))
        # CLAP wrapper may have different attribute names, try common ones
        clap_model = None
        for attr in ['clap_model', 'model', 'clap', 'text_encoder']:
            if hasattr(dummy_clap_init, attr):
                clap_model = getattr(dummy_clap_init, attr)
                if hasattr(clap_model, 'parameters'):
                    break
        
        # If no attribute worked, try getting parameters directly from wrapper
        if clap_model is None or not hasattr(clap_model, 'parameters'):
            if hasattr(dummy_clap_init, 'parameters'):
                clap_model = dummy_clap_init
        
        if clap_model is not None and hasattr(clap_model, 'parameters'):
            clap_total = sum(p.numel() for p in clap_model.parameters())
            
            logging.info(f"\nCLAP Model (frozen, not in optimizer):")
            logging.info(f"  Total:     {clap_total:>12,} parameters")
            logging.info(f"  Trainable:             0 parameters (frozen)")
            logging.info(f"  Frozen:    {clap_total:>12,} parameters")
            
            # Overall totals
            total_params = sep_total + clap_total
            total_trainable = sep_trainable  # Only separation model is trainable
            total_frozen = clap_total + sep_frozen
            
            logging.info(f"\nTotal System:")
            logging.info(f"  Total:     {total_params:>12,} parameters")
            logging.info(f"  Trainable: {total_trainable:>12,} parameters (in optimizer)")
            logging.info(f"  Frozen:    {total_frozen:>12,} parameters")
        else:
            # Log available attributes for debugging
            attrs = [a for a in dir(dummy_clap_init) if not a.startswith('_')]
            logging.warning(f"Could not access CLAP model parameters. Available attributes: {attrs}")
    except Exception as e:
        logging.warning(f"Could not count CLAP parameters: {str(e)}")
    
    logging.info("=" * 60)

    # Add graph to tensorboard with example train samples
    # _mixed, _label, _ = next(iter(val_loader))
    # args.writer.add_graph(model, (_mixed, _label))

    if use_cuda and data_parallel:
        model = nn.DataParallel(model, device_ids=device_ids)
        logging.info("Using data parallel model")
    model.to(device)

    # Set up the optimizer
    logging.info("Initializing optimizer with %s" % str(args.optim))
    optimizer = network.optimizer(model, **args.optim, data_parallel=data_parallel)
    logging.info('Learning rates initialized to:' + utils.format_lr_info(optimizer))

    lr_scheduler = optim.lr_scheduler.ReduceLROnPlateau(
        optimizer, **args.lr_sched)
    logging.info("Initialized LR scheduler with params: fix_lr_epochs=%d %s"
                 % (args.fix_lr_epochs, str(args.lr_sched)))

    base_metric = args.base_metric
    train_metrics = {}
    val_metrics = {}

    # Load the model if `args.start_epoch` is greater than 0. This will load the
    # model from epoch = `args.start_epoch - 1`
    assert args.start_epoch >=0, "start_epoch must be greater than 0."
    if args.start_epoch > 0:
        checkpoint_path = os.path.join(args.exp_dir,
                                       '%d.pt' % (args.start_epoch - 1))
        _, train_metrics, val_metrics = utils.load_checkpoint(
            checkpoint_path, model, optim=optimizer, lr_sched=lr_scheduler,
            data_parallel=data_parallel)
        logging.info("Loaded checkpoint from %s" % checkpoint_path)
        logging.info("Learning rates restored to:" + utils.format_lr_info(optimizer))

    # Training loop
    try:
        torch.autograd.set_detect_anomaly(args.detect_anomaly)
        for epoch in range(args.start_epoch, args.epochs + 1):
            logging.info("Epoch %d:" % epoch)

            # Set current epoch on training dataset for epoch-varying SNR augmentation
            data_train.current_epoch = epoch

            # Check for phase transition
            if training_phases:
                active_phase = get_active_phase(training_phases, epoch)
                if active_phase and active_phase['name'] != _current_phase_name:
                    _current_phase_name = active_phase['name']
                    data_train.snr_config = active_phase['snr_config']
                    logging.info("=" * 60)
                    logging.info("PHASE TRANSITION: %s (epoch %d)" % (active_phase['name'], epoch))
                    logging.info("  SNR speech:      [%d, %d] dB" % (
                        active_phase['snr_config']['speech']['min'],
                        active_phase['snr_config']['speech']['max']))
                    logging.info("  SNR distractors: [%d, %d] dB" % (
                        active_phase['snr_config']['distractors']['min'],
                        active_phase['snr_config']['distractors']['max']))
                    logging.info("=" * 60)

            checkpoint_file = os.path.join(args.exp_dir, '%d.pt' % epoch)
            assert not os.path.exists(checkpoint_file), \
                "Checkpoint file %s already exists" % checkpoint_file
            #print("---- begin trianivg")
            curr_train_metrics = train_epoch(model, device, optimizer,
                                             train_loader, args.n_train_items,
                                             epoch=epoch, writer=args.writer)
            #raise KeyboardInterrupt
            curr_test_metrics = test_epoch(model, device, val_loader,
                                           args.n_test_items, network.loss,
                                           network.test_metrics, epoch=epoch,
                                           writer=args.writer)
            # LR scheduler
            if epoch >= args.fix_lr_epochs:
                lr_scheduler.step(curr_test_metrics[base_metric])
                logging.info(
                    "LR after scheduling step: %s" %
                    [_['lr'] for _ in optimizer.param_groups])

            # Write metrics to tensorboard
            args.writer.add_scalars('Train', curr_train_metrics, epoch)
            args.writer.add_scalars('Val', curr_test_metrics, epoch)
            if training_phases:
                active_phase = get_active_phase(training_phases, epoch)
                if active_phase:
                    args.writer.add_scalar('Phase/speech_snr_min',
                        active_phase['snr_config']['speech']['min'], epoch)
                    args.writer.add_scalar('Phase/speech_snr_max',
                        active_phase['snr_config']['speech']['max'], epoch)
                    args.writer.add_scalar('Phase/distractors_snr_min',
                        active_phase['snr_config']['distractors']['min'], epoch)
                    args.writer.add_scalar('Phase/distractors_snr_max',
                        active_phase['snr_config']['distractors']['max'], epoch)
            args.writer.flush()

            for k in curr_train_metrics.keys():
                if not k in train_metrics:
                    # New metric - backfill with NaN for all past epochs
                    num_past_epochs = len(train_metrics.get('loss', []))
                    train_metrics[k] = [float('nan')] * num_past_epochs + [curr_train_metrics[k]]
                else:
                    train_metrics[k].append(curr_train_metrics[k])

            for k in curr_test_metrics.keys():
                if not k in val_metrics:
                    # New metric - backfill with NaN for all past epochs
                    num_past_epochs = len(val_metrics.get('loss', []))
                    val_metrics[k] = [float('nan')] * num_past_epochs + [curr_test_metrics[k]]
                else:
                    val_metrics[k].append(curr_test_metrics[k])

            if max(val_metrics[base_metric]) == val_metrics[base_metric][-1]:
                logging.info("Found best validation %s!" % base_metric)

            utils.save_checkpoint(
                checkpoint_file, epoch, model, optimizer, lr_scheduler,
                train_metrics, val_metrics, data_parallel)
            logging.info("Saved checkpoint at %s" % checkpoint_file)

            utils.save_graph(train_metrics, val_metrics, args.exp_dir)

        return train_metrics, val_metrics


    except KeyboardInterrupt:
        print("Interrupted")
    except Exception as _:  # pylint: disable=broad-except
        import traceback  # pylint: disable=import-outside-toplevel
        traceback.print_exc()


if __name__ == '__main__':
    parser = argparse.ArgumentParser()
    # Data Params
    parser.add_argument('exp_dir', type=str,
                        default='./experiments/fsd_mask_label_mult',
                        help="Path to save checkpoints and logs.")

    parser.add_argument('--n_train_items', type=int, default=None,
                        help="Number of items to train on in each epoch")
    parser.add_argument('--n_test_items', type=int, default=None,
                        help="Number of items to test.")
    parser.add_argument('--start_epoch', type=int, default=0,
                        help="Start epoch")
    parser.add_argument('--pretrain_path', type=str,
                        help="Path to pretrained weights")
    parser.add_argument('--use_cuda', dest='use_cuda', action='store_true',
                        help="Whether to use cuda")
    parser.add_argument('--gpu_ids', nargs='+', type=int, default=None,
                        help="List of GPU ids used for training. "
                        "Eg., --gpu_ids 2 4. All GPUs are used by default.")
    parser.add_argument('--detect_anomaly', dest='detect_anomaly',
                        action='store_true',
                        help="Whether to use cuda")
    parser.add_argument('--wandb', dest='wandb', action='store_true',
                        help="Whether to sync tensorboard to wandb")

    args = parser.parse_args()

    # Set the random seed for reproducible experiments
    torch.manual_seed(230)
    random.seed(230)
    np.random.seed(230)
    if args.use_cuda:
        torch.cuda.manual_seed(230)

    # Set up checkpoints
    if not os.path.exists(args.exp_dir):
        os.makedirs(args.exp_dir)

    utils.set_logger(os.path.join(args.exp_dir, 'train.log'))

    # Load model and training params
    params = utils.Params(os.path.join(args.exp_dir, 'config.json'))
    for k, v in params.__dict__.items():
        if k in vars(args):
            logging.warning("Argument %s is overwritten by config file." % k)
        vars(args)[k] = v

    # Initialize tensorboard writer
    tensorboard_dir = os.path.join(args.exp_dir, 'tensorboard')
    args.writer = SummaryWriter(tensorboard_dir, purge_step=args.start_epoch)
    if args.wandb:
        import wandb
        wandb.init(
            project='Semaudio', sync_tensorboard=True,
            dir=tensorboard_dir, name=os.path.basename(args.exp_dir))

    exec("import %s as network" % args.model)
    logging.info("Imported the model from '%s'." % args.model)

    train(args)

    args.writer.close()
    if args.wandb:
        wandb.finish()