# README # Phillip Long # August 3, 2024 # Evaluate a REMI-Style model. # python /home/pnlong/model_musescore/modeling/evaluate.py # IMPORTS ################################################## import argparse import logging import pprint import sys from os.path import exists, dirname, basename, isdir from os import mkdir, listdir from typing import Union, List import multiprocessing import math import numpy as np 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.full import MMT_STATISTIC_COLUMNS, CHUNK_SIZE, pitch_class_entropy, scale_consistency, groove_consistency, get_tracks_string from wrangling.deduplicate import FACETS from dataset import FACETS_PPL, MusicDataset, pad from train import OUTPUT_DIR, FINE_TUNING_SUFFIX from train import BATCH_SIZE as TRAIN_BATCH_SIZE from representation import Indexer, get_encoding, encode_notes, decode import utils ################################################## # CONSTANTS ################################################## # default number of samples to evaluate BATCH_SIZE = TRAIN_BATCH_SIZE # 1 N_SAMPLES = 1200 N_BATCHES = int((N_SAMPLES - 1) / BATCH_SIZE) + 1 # evaluation constants SEQ_LEN = 1024 TEMPERATURE = 1.0 FILTER = "top_k" # facets to use as loss sets LOSS_FACETS = [FACETS[0]] + FACETS_PPL # output columns OUTPUT_COLUMNS = ["model", "path"] + MMT_STATISTIC_COLUMNS + ["tracks"] + list(map(lambda loss_facet: f"loss:{loss_facet}", LOSS_FACETS)) ################################################## # HELPER FUNCTIONS ################################################## # get the base stem of a filepath basestem = lambda path: ".".join(basename(path).split(".")[:-1]) # perplexity function perplexity_function = lambda loss: math.exp(-math.log(loss)) # convert a list of losses into a single perplexity value def loss_to_perplexity(losses: List[float]) -> float: return perplexity_function(loss = sum(losses) / N_BATCHES) ################################################## # ARGUMENTS ################################################## def parse_args(args = None, namespace = None): """Parse command-line arguments.""" parser = argparse.ArgumentParser(prog = "Evaluate", description = "Evaluate a REMI-Style Model.") parser.add_argument("-d", "--input_dir", default = OUTPUT_DIR, type = str, help = "Dataset facet directory containing the model(s) (as subdirectories) to evaluate") # model parser.add_argument("--seq_len", default = SEQ_LEN, type = int, help = "Sequence length to generate") parser.add_argument("--temperature", nargs = "+", default = TEMPERATURE, type = float, help = f"Sampling temperature (default: {TEMPERATURE})") parser.add_argument("--filter", nargs = "+", default = FILTER, type = str, help = f"Sampling filter (default: '{FILTER}')") # others parser.add_argument("-g", "--gpu", default = -1, type = int, help = "GPU number") parser.add_argument("-j", "--jobs", default = int(multiprocessing.cpu_count() / 4), type = int, help = "Number of workers for data loading") parser.add_argument("-r", "--reset", action = "store_true", help = "Whether or not to regenerate samples") return parser.parse_args(args = args, namespace = namespace) ################################################## # MAIN METHOD ################################################## if __name__ == "__main__": # SET UP ################################################## # parse the command-line arguments args = parse_args() # get directories to eval model_dirs = list(filter(lambda path: isdir(path) and basename(path).split("_")[0].endswith("M"), map(lambda base: f"{args.input_dir}/{base}", listdir(args.input_dir)))) model_dirs = sorted(model_dirs, key = lambda model_dir: int(basename(model_dir).split("_")[0][:-1]) + (0.5 if FINE_TUNING_SUFFIX in basename(model_dir) else 0)) # order from least to greatest models = list(map(basename, model_dirs)) # set up the logger logging.basicConfig(level = logging.INFO, format = "%(message)s", handlers = [logging.FileHandler(filename = f"{args.input_dir}/evaluate.log", mode = "a"), logging.StreamHandler(stream = sys.stdout)]) # log command called and arguments, save arguments logging.info(f"Running command: python {' '.join(sys.argv)}") logging.info(f"Using arguments:\n{pprint.pformat(vars(args))}") args_output_filepath = f"{args.input_dir}/evaluate_args.json" logging.info(f"Saved arguments to {args_output_filepath}") utils.save_args(filepath = args_output_filepath, args = args) del args_output_filepath # data paths filepath data_paths_dirs = list(map(lambda loss_facet: f"{dirname(args.input_dir)}/{loss_facet}", LOSS_FACETS)) data_paths_filepaths = list(map(lambda data_paths_dir: data_paths_dir + "/" + ("test" if exists(f"{data_paths_dir}/test.txt") else "valid") + ".txt", data_paths_dirs)) # get the specified device device = torch.device(f"cuda:{abs(args.gpu)}" if (torch.cuda.is_available() and args.gpu != -1) else "cpu") logging.info(f"Using device: {device}") # load the encoding encoding = get_encoding() # load the indexer indexer = Indexer(data = encoding["event_code_map"]) vocabulary = utils.inverse_dict(indexer.get_dict()) # for decoding # get special tokens sos = indexer["start-of-song"] eos = indexer["end-of-song"] # get the logits filter function if args.filter == "top_k": filter_logits_fn = x_transformers.autoregressive_wrapper.top_k elif args.filter == "top_p": filter_logits_fn = x_transformers.autoregressive_wrapper.top_p elif args.filter == "top_a": filter_logits_fn = x_transformers.autoregressive_wrapper.top_a else: raise ValueError("Unknown logits filter.") # path basename to rating mapping # path_to_rating = pd.read_csv(filepath_or_buffer = args.dataset_filepath, sep = ",", header = 0, index_col = False) # path_to_rating = path_to_rating.set_index(keys = "path", drop = True)["rating"] # convert to series # path_to_rating.index = path_to_rating.index.map(basestem, na_action = "ignore") # remove filetype, keep just basename # path_to_rating = path_to_rating.to_dict() # convert to dictionary # output file output_filepath = f"{args.input_dir}/evaluation.csv" if (not exists(output_filepath)) or args.reset: # if column names need to be written pd.DataFrame(columns = OUTPUT_COLUMNS).to_csv(path_or_buf = output_filepath, sep = ",", na_rep = utils.NA_STRING, header = True, index = False, mode = "w") ################################################## # EVALUATE IF WE HAVEN'T YET ################################################## if sum(1 for _ in open(output_filepath, "r")) < ((len(models) * N_SAMPLES) + 1): # if the output is complete, based on number of lines # HELPER FUNCTION FOR EVALUATING ################################################## # helper function for evaluating a generated sequence def evaluate(codes: Union[np.array, torch.tensor]) -> List[float]: """Evaluate the results.""" # convert codes to a music object music = decode(codes = codes, encoding = encoding, vocabulary = vocabulary) # convert to a MusicRender object # return a dictionary if len(music.tracks) == 0: return utils.rep(x = np.nan, times = len(MMT_STATISTIC_COLUMNS)) + [""] else: return [ pitch_class_entropy(music = music), scale_consistency(music = music), groove_consistency(music = music), get_tracks_string(tracks = music.tracks), ] ################################################## # REPEAT WITH EACH MODEL IN INPUT DIRECTORY ################################################## for model_name, model_dir in zip(models, model_dirs): # LOAD MODEL ################################################## # get evaluation directory (where to output generations) eval_dir = f"{model_dir}/eval" if not exists(eval_dir): mkdir(eval_dir) # load training configurations train_args_filepath = f"{model_dir}/train_args.json" train_args = utils.load_json(filepath = train_args_filepath) del train_args_filepath # load dataset and data loader datasets = [MusicDataset( paths = data_paths_filepath, encoding = encoding, indexer = indexer, encode_fn = encode_notes, max_seq_len = train_args["max_seq_len"], max_beat = train_args["max_beat"], use_augmentation = train_args["aug"], ) for data_paths_filepath in data_paths_filepaths] data_loaders = [torch.utils.data.DataLoader( dataset = dataset, num_workers = args.jobs, collate_fn = dataset.collate, batch_size = BATCH_SIZE, shuffle = False ) for dataset in datasets] data_iters = [iter(data_loader) for data_loader in data_loaders] # create the model model = x_transformers.TransformerWrapper( num_tokens = len(indexer), max_seq_len = train_args["max_seq_len"], attn_layers = x_transformers.Decoder( dim = train_args["dim"], depth = train_args["layers"], heads = train_args["heads"], rotary_pos_emb = train_args["rel_pos_emb"], emb_dropout = train_args["dropout"], attn_dropout = train_args["dropout"], ff_dropout = train_args["dropout"], ), use_abs_pos_emb = train_args["abs_pos_emb"], ).to(device) model = x_transformers.AutoregressiveWrapper(net = model) # load the checkpoint checkpoint_filepath = f"{model_dir}/checkpoints/best_model.valid.pth" model_state_dict = torch.load(f = checkpoint_filepath, map_location = device, weights_only = True) model.load_state_dict(state_dict = model_state_dict) model.eval() del checkpoint_filepath, model_state_dict # free up memory ################################################## # EVALUATE ################################################## # iterate over the dataset with torch.no_grad(): for i in tqdm(iterable = range(N_BATCHES), desc = f"Evaluating the {model_name} Model"): # get number of samples to calculate n_samples_in_batch = (((N_SAMPLES - 1) % BATCH_SIZE) + 1) if (i == (N_BATCHES - 1)) else BATCH_SIZE # GENERATE, EVALUATE MMT STATISTICS ################################################## # get output filepaths for generated sequences generated_output_filepaths = list(map(lambda j: f"{eval_dir}/{(i * BATCH_SIZE) + j}.npy", range(n_samples_in_batch))) # generate if needed if (not all(map(exists, generated_output_filepaths))) or args.reset: # get start tokens prefix = torch.ones(size = (n_samples_in_batch, 1), dtype = torch.long, device = device) * sos # generate new samples; unconditioned generation generated = model.generate( prompts = prefix, seq_len = args.seq_len, eos_token = eos, temperature = args.temperature, filter_logits_fn = filter_logits_fn, ) generated = torch.cat(tensors = (prefix, generated), dim = 1).cpu().numpy() # save generation for j in range(len(generated)): np.save(file = generated_output_filepaths[j], arr = generated[j]) # save generation to file # reload generated files else: # load in generated content generated = pad(data = list(map(np.load, generated_output_filepaths))) # analyze with multiprocessing.Pool(processes = args.jobs) as pool: results = pool.map(func = evaluate, iterable = generated, chunksize = CHUNK_SIZE) ################################################## # LOSS FOR PERPLEXITY ################################################## # initialize loss_batch array loss_batch = utils.rep(x = 0.0, times = len(LOSS_FACETS)) # calculate loss for each loss facet for j in range(len(LOSS_FACETS)): # get batch try: batch = next(data_iters[j]) except (StopIteration): data_iters[j] = iter(data_loaders[j]) # reinitialize dataset iterator if necessary batch = next(data_iters[j]) # get loss value through forward pass loss_batch_facet = model( x = batch["seq"][:n_samples_in_batch].to(device), return_outputs = False, mask = batch["mask"][:n_samples_in_batch].to(device), ) # convert to non-torch number loss_batch[j] = float(loss_batch_facet) / n_samples_in_batch # divide by number of samples so we get per sample loss, instead of per batch loss del loss_batch_facet # free up memory # get ratings # if j == len(LOSS_FACETS) - 1: # ratings = list(map(lambda path: path_to_rating.get(basestem(path), 0), batch["name"][:n_samples_in_batch])) ################################################## # OUTPUT RESULTS ################################################## # write results to file results = pd.DataFrame(data = map(lambda j: [model_name, generated_output_filepaths[j]] + results[j] + loss_batch, range(n_samples_in_batch)), columns = OUTPUT_COLUMNS) results.to_csv(path_or_buf = output_filepath, sep = ",", na_rep = utils.NA_STRING, header = False, index = False, mode = "a") ################################################## ################################################## # free up memory del model, datasets, data_loaders, data_iters ################################################## ################################################## # LOG STATISTICS ################################################## # log statistics bar_width = 50 results = pd.read_csv(filepath_or_buffer = output_filepath, sep = ",", na_values = utils.NA_STRING, header = 0, index_col = False) # load in previous values for model in models: results_model = results[results["model"] == model] logging.info(f"\n{f' {model} ':=^{bar_width}}") for mmt_statistic in MMT_STATISTIC_COLUMNS: logging.info(f"{mmt_statistic.replace('_', ' ').title()}: mean = {np.nanmean(a = results_model[mmt_statistic], axis = 0):.4f}, std = {np.nanstd(a = results_model[mmt_statistic], axis = 0):.4f}") logging.info(f"Perplexity (All): {loss_to_perplexity(losses = results_model[f'loss:all']):.4f}") print("") ################################################## ##################################################