modeling/train.py

# README
# Phillip Long
# August 1, 2024

# Train a REMI-Style model.

# python /home/pnlong/model_musescore/modeling/train.py

# IMPORTS
##################################################

import argparse
import logging
import pprint
import sys
from os.path import exists, basename
from os import makedirs, mkdir
from multiprocessing import cpu_count # for calculating num_workers
import wandb
import datetime # for creating wandb run names linked to time of run

import pandas as pd
import torch
import torch.utils.data
from tqdm import tqdm
import warnings
warnings.simplefilter(action = "ignore", category = FutureWarning)
import x_transformers

from os.path import dirname, realpath
import sys
sys.path.insert(0, dirname(realpath(__file__)))
sys.path.insert(0, dirname(dirname(realpath(__file__))))

from wrangling.deduplicate import FACETS
from dataset import PARTITIONS, MusicDataset
from dataset import OUTPUT_DIR as DATASET_OUTPUT_DIR
from representation import Indexer, get_encoding, encode_notes
import utils

##################################################


# CONSTANTS
##################################################

# paths
INPUT_DIR = f"{DATASET_OUTPUT_DIR}/{FACETS[0]}"
PATHS_TRAIN = f"{INPUT_DIR}/train.txt"
PATHS_VALID = f"{INPUT_DIR}/valid.txt"
OUTPUT_DIR = INPUT_DIR
FINE_TUNING_SUFFIX = "ft"

# model constants
MAX_SEQ_LEN = 1024
MAX_BEAT = 64
DIM = 512
N_LAYERS = 6
N_HEADS = 8
DROPOUT = 0.2

# training constants
N_STEPS = 100000
N_VALID_STEPS = 1000
N_SAVE_STEPS = 5000
EARLY_STOPPING_TOLERANCE = 20
LEARNING_RATE = 0.0005
LEARNING_RATE_WARMUP_STEPS = 5000
LEARNING_RATE_DECAY_STEPS = 100000
LEARNING_RATE_DECAY_MULTIPLIER = 0.1
GRAD_NORM_CLIP = 1.0

# data loader constants
BATCH_SIZE = 12

# more constants
RELEVANT_PARTITIONS = list(PARTITIONS.keys())[:-1]
LOSS_OUTPUT_COLUMNS = ["step", "partition", "loss"]

# wandb
PROJECT_NAME = "PDMX"
INFER_RUN_NAME_STRING = "-1"

##################################################


# HELPER FUNCTIONS
##################################################

def get_lr_multiplier(step: int, warmup_steps: int, decay_end_steps: int, decay_end_multiplier: float) -> float:
    """Return the learning rate multiplier with a warmup and decay schedule.

    The learning rate multiplier starts from 0 and linearly increases to 1
    after `warmup_steps`. After that, it linearly decreases to
    `decay_end_multiplier` until `decay_end_steps` is reached.

    """
    if step < warmup_steps:
        return (step + 1) / warmup_steps
    if step > decay_end_steps:
        return decay_end_multiplier
    position = (step - warmup_steps) / (decay_end_steps - warmup_steps)
    return 1 - (1 - decay_end_multiplier) * position

##################################################


# ARGUMENTS
##################################################

def parse_args(args = None, namespace = None):
    """Parse command-line arguments."""
    parser = argparse.ArgumentParser(prog = "Train", description = "Train a REMI-Style Model.")
    parser.add_argument("-pt", "--paths_train", default = PATHS_TRAIN, type = str, help = ".txt file with absolute filepaths to training dataset")
    parser.add_argument("-pv", "--paths_valid", default = PATHS_VALID, type = str, help = ".txt file with absolute filepaths to validation dataset")
    parser.add_argument("-o", "--output_dir", default = OUTPUT_DIR, type = str, help = "Output directory")
    parser.add_argument("-ft", "--fine_tune", action = "store_true", help = "Whether this is fine tuning")
    # data
    parser.add_argument("--aug", action = argparse.BooleanOptionalAction, default = True, help = "Whether to use data augmentation")
    # model
    parser.add_argument("--max_seq_len", default = MAX_SEQ_LEN, type = int, help = "Maximum sequence length")
    parser.add_argument("--max_beat", default = MAX_BEAT, type = int, help = "Maximum beat")
    parser.add_argument("--dim", default = DIM, type = int, help = "Model dimension")
    parser.add_argument("-l", "--layers", default = N_LAYERS, type = int, help = "Number of layers")
    parser.add_argument("--heads", default = N_HEADS, type = int, help = "Number of attention heads")
    parser.add_argument("--dropout", default = DROPOUT, type = float, help = "Dropout rate")
    parser.add_argument("--abs_pos_emb", action = argparse.BooleanOptionalAction, default = True, help = "Whether to use absolute positional embedding")
    parser.add_argument("--rel_pos_emb", action = argparse.BooleanOptionalAction, default = False, help = "Whether to use relative positional embedding")
    # training
    parser.add_argument("--steps", default = N_STEPS, type = int, help = "Number of steps")
    parser.add_argument("--valid_steps", default = N_VALID_STEPS, type = int, help = "Validation frequency")
    parser.add_argument("--save_steps", default = N_SAVE_STEPS, type = int, help = "Frequency to save model parameters")
    parser.add_argument("--early_stopping", action = argparse.BooleanOptionalAction, default = False, help = "Whether to use early stopping")
    parser.add_argument("--early_stopping_tolerance", default = EARLY_STOPPING_TOLERANCE, type = int, help = "Number of extra validation rounds before early stopping")
    parser.add_argument("-lr", "--learning_rate", default = LEARNING_RATE, type = float, help = "Learning rate")
    parser.add_argument("--lr_warmup_steps", default = LEARNING_RATE_WARMUP_STEPS, type = int, help = "Learning rate warmup steps")
    parser.add_argument("--lr_decay_steps", default = LEARNING_RATE_DECAY_STEPS, type = int, help = "Learning rate decay end steps")
    parser.add_argument("--lr_decay_multiplier", default = LEARNING_RATE_DECAY_MULTIPLIER, type = float, help = "Learning rate multiplier at the end")
    parser.add_argument("--grad_norm_clip", default = GRAD_NORM_CLIP, type = float, help = "Gradient norm clipping")
    # others
    parser.add_argument("-g", "--gpu", default = -1, type = int, help = "GPU number")
    parser.add_argument("-j", "--jobs", default = int(cpu_count() / 4), type = int, help = "Number of workers for data loading")
    parser.add_argument("-r", "--resume", default = None, type = str, help = "Provide the wandb run name/id to resume a run")
    return parser.parse_args(args = args, namespace = namespace)

##################################################


# MAIN METHOD
##################################################

if __name__ == "__main__":

    # LOAD UP MODEL
    ##################################################

    # parse the command-line arguments
    args = parse_args()

    # check filepath arguments
    if not exists(args.paths_train):
        raise ValueError("Invalid --paths_train argument. File does not exist.")
    if not exists(args.paths_valid):
        raise ValueError("Invalid --paths_valid argument. File does not exist.")
    run_name = args.resume # get runname
    args.resume = (run_name != None) # convert to boolean value
    
    # get the specified device
    device = torch.device(f"cuda:{abs(args.gpu)}" if (torch.cuda.is_available() and args.gpu != -1) else "cpu")
    print(f"Using device: {device}")

    # load the encoding
    encoding = get_encoding()

    # load the indexer
    indexer = Indexer(data = encoding["event_code_map"])

    # create the dataset and data loader
    print(f"Creating the data loader...")
    dataset = {
        "train": MusicDataset(paths = args.paths_train, encoding = encoding, indexer = indexer, encode_fn = encode_notes, max_seq_len = args.max_seq_len, max_beat = args.max_beat, use_augmentation = args.aug),
        "valid": MusicDataset(paths = args.paths_valid, encoding = encoding, indexer = indexer, encode_fn = encode_notes, max_seq_len = args.max_seq_len, max_beat = args.max_beat, use_augmentation = False)
        }
    data_loader = {
        "train": torch.utils.data.DataLoader(dataset = dataset["train"], batch_size = BATCH_SIZE, shuffle = True, num_workers = args.jobs, collate_fn = dataset["train"].collate),
        "valid": torch.utils.data.DataLoader(dataset = dataset["valid"], batch_size = BATCH_SIZE, shuffle = False, num_workers = args.jobs, collate_fn = dataset["valid"].collate)
    }

    # create the model
    print(f"Creating model...")
    model = x_transformers.TransformerWrapper(
        num_tokens = len(indexer),
        max_seq_len = args.max_seq_len,
        attn_layers = x_transformers.Decoder(
            dim = args.dim,
            depth = args.layers,
            heads = args.heads,
            rotary_pos_emb = args.rel_pos_emb,
            emb_dropout = args.dropout,
            attn_dropout = args.dropout,
            ff_dropout = args.dropout,
        ),
        use_abs_pos_emb = args.abs_pos_emb,
    ).to(device)
    model = x_transformers.AutoregressiveWrapper(net = model)
    n_parameters = sum(p.numel() for p in model.parameters()) # statistics
    n_parameters_trainable = sum(p.numel() for p in model.parameters() if p.requires_grad) # statistics (model size)

    # determine the output directory based on arguments
    model_size = int(n_parameters_trainable / 1e+6)
    output_parent_dir = args.output_dir
    output_dir_name = f"{model_size}M"
    output_dir = f"{output_parent_dir}/{output_dir_name}" # custom output directory based on arguments
    original_output_dir_name, original_output_dir = output_dir_name, output_dir # save in case those values are changed
    if not exists(output_dir):
        if args.fine_tune:
            raise NotADirectoryError(f"No {output_dir_name} model exists at {output_dir} to fine tune.")
        else:
            makedirs(output_dir)
    elif args.fine_tune: # output_dir exists and we want to fine tune, then set the output directory to the fine tuning directory
        output_dir_name += f"_{FINE_TUNING_SUFFIX}"
        output_dir = f"{output_parent_dir}/{output_dir_name}"
        if not exists(output_dir):
            makedirs(output_dir)
    checkpoints_dir, original_checkpoints_dir = f"{output_dir}/checkpoints", f"{original_output_dir}/checkpoints" # models will be stored in the output directory
    checkpoints_dir_for_model_reloading = original_checkpoints_dir if (args.fine_tune and (not args.resume)) else checkpoints_dir
    if not exists(checkpoints_dir):
        mkdir(checkpoints_dir)

    # start a new wandb run to track the script
    group_name = basename(output_parent_dir)
    if run_name == INFER_RUN_NAME_STRING:
        run_name = next(filter(lambda name: name.startswith(output_dir_name), (run.name for run in wandb.Api().runs(f"philly/{PROJECT_NAME}", filters = {"group": group_name}))), None) # try to infer the run name
        args.resume = (run_name != None) # redefine args.resume in the event that no run name was supplied, but we can't infer one either
    if run_name is None: # in the event we need to create a new run name
        current_datetime = datetime.datetime.now().strftime("%m%d%y%H%M%S")
        run_name = f"{output_dir_name}-{current_datetime}"
    run = wandb.init(config = dict(vars(args), **{"n_parameters": n_parameters, "n_parameters_trainable": n_parameters_trainable}), resume = "allow", project = PROJECT_NAME, group = group_name, name = run_name, id = run_name) # set project title, configure with hyperparameters

    # set up the logger
    logging_output_filepath = f"{output_dir}/train.log"
    log_hyperparameters = not (args.resume and exists(logging_output_filepath))
    logging.basicConfig(level = logging.INFO, format = "%(message)s", handlers = [logging.FileHandler(filename = logging_output_filepath, mode = "a" if args.resume else "w"), logging.StreamHandler(stream = sys.stdout)])

    # log command called and arguments, save arguments
    if log_hyperparameters:
        logging.info(f"Running command: python {' '.join(sys.argv)}")
        logging.info(f"Using arguments:\n{pprint.pformat(vars(args))}")
        args_output_filepath = f"{output_dir}/train_args.json"
        logging.info(f"Saved arguments to {args_output_filepath}")
        utils.save_args(filepath = args_output_filepath, args = args)
        del args_output_filepath # clear up memory
    else: # print previous loggings to stdout
        with open(logging_output_filepath, "r") as logging_output:
            print(logging_output.read())

    # load previous model and summarize if needed
    def log_model_size():
        """Log the size of the model."""
        logging.info(f"Number of parameters: {n_parameters:,}")
        logging.info(f"Number of trainable parameters: {n_parameters_trainable:,}")
    best_model_filepath = {partition: f"{checkpoints_dir_for_model_reloading}/best_model.{partition}.pth" for partition in RELEVANT_PARTITIONS}
    if args.fine_tune and args.resume and (not all(map(exists, best_model_filepath.values()))): # reset best model filepath if we are asking to resume a fine-tuning run that doesn't yet exist
        best_model_filepath = {partition: f"{original_checkpoints_dir}/best_model.{partition}.pth" for partition in RELEVANT_PARTITIONS} # change back to default fine-tuning directory
    if args.fine_tune and (not all(map(exists, best_model_filepath.values()))): # check if we can even fine tune and the state dict files exist
        raise FileNotFoundError(f"Cannot fine tune {original_output_dir_name} model, since relevant state_dict files do not exist.")
    if (args.resume or args.fine_tune) and all(map(exists, best_model_filepath.values())):
        model.load_state_dict(torch.load(f = best_model_filepath["valid"], weights_only = True))
        if args.fine_tune and log_hyperparameters:
            log_model_size()
    else:
        log_model_size()
    best_model_filepath = {partition: f"{checkpoints_dir}/best_model.{partition}.pth" for partition in RELEVANT_PARTITIONS} # reset in case output_dir and original_output_dir were different (account for fine tuning)
    
    # create the optimizer
    optimizer = torch.optim.Adam(params = model.parameters(), lr = args.learning_rate)
    best_optimizer_filepath = {partition: f"{checkpoints_dir}/best_optimizer.{partition}.pth" for partition in RELEVANT_PARTITIONS}
    if args.resume and all(map(exists, best_optimizer_filepath.values())):
        optimizer.load_state_dict(torch.load(f = best_optimizer_filepath["valid"], weights_only = True))

    # create the scheduler
    scheduler = torch.optim.lr_scheduler.LambdaLR(optimizer = optimizer, lr_lambda = lambda step: get_lr_multiplier(step = step, warmup_steps = args.lr_warmup_steps, decay_end_steps = args.lr_decay_steps, decay_end_multiplier = args.lr_decay_multiplier))
    best_scheduler_filepath = {partition: f"{checkpoints_dir}/best_scheduler.{partition}.pth" for partition in RELEVANT_PARTITIONS}
    if args.resume and all(map(exists, best_scheduler_filepath.values())):
        scheduler.load_state_dict(torch.load(f = best_scheduler_filepath["valid"], weights_only = True))

    ##################################################


    # TRAINING PROCESS
    ##################################################

    # create a file to record loss metrics
    output_filepath = f"{output_dir}/loss.csv"
    loss_columns_must_be_written = not (exists(output_filepath) and args.resume) # whether or not to write column names
    if loss_columns_must_be_written: # if column names need to be written
        pd.DataFrame(columns = LOSS_OUTPUT_COLUMNS).to_csv(path_or_buf = output_filepath, sep = ",", na_rep = utils.NA_STRING, header = True, index = False, mode = "w")

    # initialize variables
    step = 0
    min_loss = {partition: float("inf") for partition in RELEVANT_PARTITIONS}
    if not loss_columns_must_be_written: # load in previous loss info
        previous_loss = pd.read_csv(filepath_or_buffer = output_filepath, sep = ",", na_values = utils.NA_STRING, header = 0, index_col = False) # read in previous loss values
        if len(previous_loss) > 0:
            for partition in RELEVANT_PARTITIONS:
                min_loss[partition] = float(previous_loss[previous_loss["partition"] == partition]["loss"].min(axis = 0)) # get minimum loss
            step = int(previous_loss["step"].max(axis = 0)) # update step
        del previous_loss
    if args.early_stopping: # stop early?
        count_early_stopping = 0

    # print current step
    print(f"Current Step: {step:,}")

    # iterate for the specified number of steps
    train_iterator = iter(data_loader["train"])
    while step < args.steps:

        # to store loss/accuracy values
        loss = {partition: 0.0 for partition in RELEVANT_PARTITIONS}

        # TRAIN
        ##################################################

        logging.info(f"Training...")

        model.train()
        count = 0 # count number of batches
        # recent_losses = np.empty(shape = (0,)) # for moving average of loss
        for batch in (progress_bar := tqdm(iterable = range(args.valid_steps), desc = "Training")):

            # get next batch
            try:
                batch = next(train_iterator)
            except (StopIteration):
                train_iterator = iter(data_loader["train"]) # reinitialize dataset iterator
                batch = next(train_iterator)

            # get input and output pair
            seq = batch["seq"].to(device)
            mask = batch["mask"].to(device)

            # calculate loss for the batch
            optimizer.zero_grad()
            loss_batch = model(x = seq, return_outputs = False, mask = mask)

            # update parameters according to loss
            loss_batch.backward() # calculate gradients
            torch.nn.utils.clip_grad_norm_(parameters = model.parameters(), max_norm = args.grad_norm_clip)
            optimizer.step() # update parameters
            scheduler.step() # update scheduler

            # compute the moving average of the loss
            # recent_losses = np.append(arr = recent_losses, values = [float(loss_batch)], axis = 0) # float(loss_batch) because it has a gradient attribute
            # if len(recent_losses) > 10:
            #     recent_losses = np.delete(arr = recent_losses, obj = 0, axis = 0)
            # loss_batch = np.mean(a = recent_losses, axis = 0)
                        
            # set progress bar
            loss_batch = float(loss_batch) # float(loss_batch) because it has a gradient attribute
            progress_bar.set_postfix(loss = f"{loss_batch:8.4f}")

            # log training loss/accuracy for wandb
            wandb.log({f"train": loss_batch}, step = step)

            # update count
            count += len(batch)

            # add to total loss tracker
            loss["train"] += loss_batch * len(batch)

            # increment step
            step += 1

        # release GPU memory right away
        del seq, mask, loss_batch

        # compute average loss across batches
        loss["train"] /= count
        
        # log train info for wandb
        wandb.log({"train": loss["train"]}, step = step)

        # save state dict
        if (step % args.save_steps) == 0:
            steps_for_save = int(step / args.valid_steps)
            torch.save(obj = model.state_dict(), f = f"{checkpoints_dir}/model.{steps_for_save}.pth") # save the model
            torch.save(obj = optimizer.state_dict(), f = f"{checkpoints_dir}/optimizer.{steps_for_save}.pth") # save the optimizer state
            torch.save(obj = scheduler.state_dict(), f = f"{checkpoints_dir}/scheduler.{steps_for_save}.pth") # save the scheduler state

        ##################################################


        # VALIDATE
        ##################################################

        logging.info(f"Validating...")

        model.eval()
        with torch.no_grad():

            count = 0 # count number of batches
            for batch in tqdm(iterable = data_loader["valid"], desc = "Validating"):

                # get input and output pair
                seq = batch["seq"].to(device)
                mask = batch["mask"].to(device)

                # pass through the model
                loss_batch = model(x = seq, return_outputs = False, mask = mask)

                # update count
                count += len(batch)

                # add to total loss tracker
                loss["valid"] += float(loss_batch) * len(batch)
                
        # release GPU memory right away
        del seq, mask, loss_batch

        # compute average loss across batches
        loss["valid"] /= count

        # output statistics
        logging.info(f"Validation loss: {loss['valid']:.4f}")

        # log validation info for wandb
        wandb.log({"valid": loss["valid"]}, step = step)

        ##################################################


        # RECORD LOSS, SAVE MODEL
        ##################################################

        # write output to file
        output = pd.DataFrame(
            data = dict(zip(
                LOSS_OUTPUT_COLUMNS,
                (utils.rep(x = step, times = len(RELEVANT_PARTITIONS)), RELEVANT_PARTITIONS, loss.values()))),
            columns = LOSS_OUTPUT_COLUMNS)
        output.to_csv(path_or_buf = output_filepath, sep = ",", na_rep = utils.NA_STRING, header = False, index = False, mode = "a")

        # see whether or not to save
        is_an_improvement = False # whether or not the loss has improved
        for partition in RELEVANT_PARTITIONS:
            partition_loss = loss[partition]
            if partition_loss < min_loss[partition]:
                min_loss[partition] = partition_loss
                logging.info(f"Best {partition}_loss so far!") # log paths to which states were saved
                torch.save(obj = model.state_dict(), f = best_model_filepath[partition]) # save the model
                torch.save(obj = optimizer.state_dict(), f = best_optimizer_filepath[partition]) # save the optimizer state
                torch.save(obj = scheduler.state_dict(), f = best_scheduler_filepath[partition]) # save the scheduler state
                if args.early_stopping: # reset the early stopping counter if we found a better model
                    count_early_stopping = 0
                    is_an_improvement = True # we only care about the lack of improvement when we are thinking about early stopping, so turn off this boolean flag, since there was an improvement
        
        # increment the early stopping counter if no improvement is found
        if (not is_an_improvement) and args.early_stopping:
            count_early_stopping += 1 # increment

        # early stopping
        if args.early_stopping and (count_early_stopping > args.early_stopping_tolerance):
            logging.info(f"Stopped the training for no improvements in {args.early_stopping_tolerance} rounds.")
            break

        ##################################################

    ##################################################

    
    # STATISTICS AND CONCLUSION
    ##################################################

    # log minimum validation loss
    logging.info(f"Minimum validation loss achieved: {min_loss['valid']}")
    wandb.log({f"min_valid_loss": min_loss['valid']})

    # finish the wandb run
    wandb.finish()

    # output model name to list of models
    models_output_filepath = f"{output_parent_dir}/models.txt"
    if exists(models_output_filepath):
        with open(models_output_filepath, "r") as models_output: # read in list of trained models
            models = {model.strip() for model in models_output.readlines()} # use a set because better for `in` operations
    else:
        models = set()
    with open(models_output_filepath, "a") as models_output:
        if output_dir_name not in models: # check if in list of trained models
            models_output.write(output_dir_name + "\n") # add model to list of trained models if it isn't already there

    ##################################################

##################################################